From 1e167eb8ffac56f1299dfbec2851ae7870425580 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:15 +0000
Subject: [PATCH 1/8] cgen: decouple `TLoc` from `TSym`

Store all locs associated with symbols in lookup tables, with `TSym.loc`
only being queried (but never written) for the external name or user-
provided flags.

In order to efficiently associate a `TSym` with a code-generator `TLoc`,
each `TSym` stores a one-based index (`locId`) into one of the code
generator's lookup tables. A table-based approach would have too, but
it's slightly slower (~1.4% when building the compiler itselfs).

In general, `cgen` becomes more strict with locs, now requiring globals,
constants, and parameters to have their loc set-up once at definition
processing time. Procedures, fields, and locals still need to
support ad-hoc loc setup.

Other changes:
- writing the mangled names to NDI files is temporarily disabled
- in symbol definitions contexts, `loc.t` is replaced with the querying
  the symbol's type directly (both are equivalent)
- locs for constants now store a symbol node in their `lode` field
---
 compiler/ast/ast.nim               |   3 +-
 compiler/ast/ast_types.nim         |   3 +-
 compiler/backend/ccgcalls.nim      |   2 +-
 compiler/backend/ccgexprs.nim      |  96 ++++++++++-------------
 compiler/backend/ccgreset.nim      |  12 ++-
 compiler/backend/ccgstmts.nim      |  24 +++---
 compiler/backend/ccgthreadvars.nim |   8 +-
 compiler/backend/ccgtypes.nim      | 120 ++++++++++++++---------------
 compiler/backend/cgen.nim          | 101 +++++++++++++-----------
 compiler/backend/cgendata.nim      |  68 ++++++++++++++++
 compiler/utils/containers.nim      |   5 ++
 11 files changed, 253 insertions(+), 189 deletions(-)

diff --git a/compiler/ast/ast.nim b/compiler/ast/ast.nim
index ff90b61364d..72f7215f66a 100644
--- a/compiler/ast/ast.nim
+++ b/compiler/ast/ast.nim
@@ -510,7 +510,8 @@ template transitionSymKindCommon*(k: TSymKind) =
   s[] = TSym(kind: k, itemId: obj.itemId, magic: obj.magic, typ: obj.typ, name: obj.name,
              info: obj.info, owner: obj.owner, flags: obj.flags, ast: obj.ast,
              options: obj.options, position: obj.position, offset: obj.offset,
-             loc: obj.loc, annex: obj.annex, constraint: obj.constraint)
+             loc: obj.loc, locId: obj.locId,
+             annex: obj.annex, constraint: obj.constraint)
   when defined(nimsuggest):
     s.allUsages = obj.allUsages
 
diff --git a/compiler/ast/ast_types.nim b/compiler/ast/ast_types.nim
index e3a5704a94b..d7136e464bb 100644
--- a/compiler/ast/ast_types.nim
+++ b/compiler/ast/ast_types.nim
@@ -1714,6 +1714,8 @@ type
                               ## for variables a slot index for the evaluator
     offset*: int              ## offset of record field
     loc*: TLoc
+    locId*: uint32            ## associates the symbol with a loc in the C code
+                              ## generator. 0 means unset.
     annex*: PLib              ## additional fields (seldom used, so we use a
                               ## reference to another object to save space)
     constraint*: PNode        ## additional constraints like 'lit|result'; also
@@ -1759,7 +1761,6 @@ type
     align*: int16             ## the type's alignment requirements
     paddingAtEnd*: int16      ##
     lockLevel*: TLockLevel    ## lock level as required for deadlock checking
-    loc*: TLoc
     typeInst*: PType          ## for generic instantiations the tyGenericInst that led to this
                               ## type; for tyError the previous type if avaiable
     uniqueId*: ItemId         ## due to a design mistake, we need to keep the real ID here as it
diff --git a/compiler/backend/ccgcalls.nim b/compiler/backend/ccgcalls.nim
index 3df75cf23c5..dca43038aa3 100644
--- a/compiler/backend/ccgcalls.nim
+++ b/compiler/backend/ccgcalls.nim
@@ -467,7 +467,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
 proc notYetAlive(n: PNode): bool {.inline.} =
   let r = getRoot(n)
-  result = r != nil and r.loc.lode == nil
+  result = r != nil and r.locId == 0
 
 proc isInactiveDestructorCall(p: BProc, e: PNode): bool =
   #[ Consider this example.
diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index 887a73c9b51..426972274c3 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -602,9 +602,8 @@ proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
   else:
     var rtyp: PType
     let field = lookupFieldAgain(p, ty, f, r, addr rtyp)
-    if field.loc.r == "" and rtyp != nil: fillObjectFields(p.module, rtyp)
-    if field.loc.r == "": internalError(p.config, e.info, "genRecordField 3 " & typeToString(ty))
-    r.addf(".$1", [field.loc.r])
+    ensureObjectFields(p.module, field, rtyp)
+    r.addf(".$1", [p.fieldLoc(field).r])
     putIntoDest(p, d, e, r, a.storage)
 
 proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc)
@@ -624,7 +623,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
     initLoc(v, locExpr, disc, OnUnknown)
     v.r = obj
     v.r.add(".")
-    v.r.add(disc.sym.loc.r)
+    v.r.add(p.fieldLoc(disc.sym).r)
     genInExprAux(p, it, u, v, test)
     var msg = ""
     if optDeclaredLocs in p.config.globalOptions:
@@ -686,11 +685,10 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
     var r = rdLoc(a)
     let f = e[0][1].sym
     let field = lookupFieldAgain(p, ty, f, r)
-    if field.loc.r == "": fillObjectFields(p.module, ty)
-    if field.loc.r == "":
-      internalError(p.config, e.info, "genCheckedRecordField") # generate the checks:
+    ensureObjectFields(p.module, field, ty)
+    # generate the checks:
     genFieldCheck(p, e, r, field)
-    r.add(ropecg(p.module, ".$1", [field.loc.r]))
+    r.add(ropecg(p.module, ".$1", [p.fieldLoc(field).r]))
     putIntoDest(p, d, e[0], r, a.storage)
   else:
     genRecordField(p, e[0], d)
@@ -1040,10 +1038,8 @@ proc specializeInitObjectN(p: BProc, accessor: Rope, n: PNode, typ: PType) =
     p.config.internalAssert(n[0].kind == nkSym, n.info,
                             "specializeInitObjectN")
     let disc = n[0].sym
-    if disc.loc.r == "": fillObjectFields(p.module, typ)
-    p.config.internalAssert(disc.loc.t != nil, n.info,
-                            "specializeInitObjectN()")
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.r])
+    ensureObjectFields(p.module, disc, typ)
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, p.fieldLoc(disc).r])
     for i in 1..<n.len:
       let branch = n[i]
       assert branch.kind in {nkOfBranch, nkElse}
@@ -1057,10 +1053,8 @@ proc specializeInitObjectN(p: BProc, accessor: Rope, n: PNode, typ: PType) =
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
-    if field.loc.r == "": fillObjectFields(p.module, typ)
-    p.config.internalAssert(field.loc.t != nil, n.info,
-                            "specializeInitObjectN()")
-    specializeInitObjectL(p, accessor, field.loc)
+    ensureObjectFields(p.module, field, typ)
+    specializeInitObjectL(p, accessor, p.fieldLoc(field))
   else: internalError(p.config, n.info, "specializeInitObjectN()")
 
 proc specializeInitObject(p: BProc, accessor: Rope, typ: PType,
@@ -1188,12 +1182,11 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
     var tmp2: TLoc
     tmp2.r = r
     let field = lookupFieldAgain(p, ty, it[0].sym, tmp2.r)
-    if field.loc.r == "": fillObjectFields(p.module, ty)
-    if field.loc.r == "": internalError(p.config, e.info, "genObjConstr")
+    ensureObjectFields(p.module, field, ty)
     if it.len == 3 and optFieldCheck in p.options:
       genFieldCheck(p, it[2], r, field)
     tmp2.r.add(".")
-    tmp2.r.add(field.loc.r)
+    tmp2.r.add(p.fieldLoc(field).r)
     if useTemp:
       tmp2.k = locTemp
       tmp2.storage = if isRef: OnHeap else: OnStack
@@ -1891,7 +1884,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
     let member =
       if t.kind == tyTuple:
         "Field" & rope(dotExpr[1].sym.position)
-      else: dotExpr[1].sym.loc.r
+      else: p.fieldLoc(dotExpr[1].sym).r
     putIntoDest(p,d,e, "((NI)offsetof($1, $2))" % [tname, member])
   of mChr: genSomeCast(p, e, d)
   of mOrd: genOrd(p, e, d)
@@ -2141,23 +2134,25 @@ proc useConst*(m: BModule; sym: PSym) =
   if lfNoDecl in sym.loc.flags:
     return
 
-  assert(sym.loc.r != "", $sym.name.s & $sym.itemId)
   let q = findPendingModule(m, sym)
   # only emit a declaration if the constant is used in a module that is not the
   # one the constant is part of
   if q != m and not containsOrIncl(m.declaredThings, sym.id):
     let headerDecl = "extern NIM_CONST $1 $2;$n" %
-        [getTypeDesc(m, sym.loc.t, skVar), sym.loc.r]
+        [getTypeDesc(m, sym.typ, skVar), q.consts[sym].r]
     m.s[cfsData].add(headerDecl)
 
 proc genConstDefinition*(q: BModule; sym: PSym) =
-  fillConstLoc(q, sym) # all consts need a valid loc
+  let name = mangleName(q, sym)
   if lfNoDecl notin sym.loc.flags:
     let p = newProc(nil, q)
     q.s[cfsData].addf("N_LIB_PRIVATE NIM_CONST $1 $2 = $3;$n",
-        [getTypeDesc(q, sym.typ), sym.loc.r,
+        [getTypeDesc(q, sym.typ), name,
         genBracedInit(p, sym.ast, isConst = true, sym.typ)])
 
+  # all constants need a loc:
+  q.consts.put(sym, initLoc(locData, newSymNode(sym), name, OnStatic))
+
 proc expr(p: BProc, n: PNode, d: var TLoc) =
   when defined(nimCompilerStacktraceHints):
     frameMsg(p.config, n)
@@ -2173,52 +2168,43 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
           rsemCannotCodegenCompiletimeProc, sym))
 
       useProc(p.module, sym)
-
-      if sym.loc.r == "" or sym.loc.lode == nil:
-        internalError(p.config, n.info, "expr: proc not init " & sym.name.s)
-      putLocIntoDest(p, d, sym.loc)
+      putLocIntoDest(p, d, p.module.procs[sym].loc)
     of skConst:
       if isSimpleConst(sym.typ):
         putIntoDest(p, d, n, genLiteral(p, sym.ast, sym.typ), OnStatic)
       else:
         useConst(p.module, sym)
-        assert((sym.loc.r != "") and (sym.loc.t != nil))
-        putLocIntoDest(p, d, sym.loc)
-    of skVar, skForVar, skResult, skLet:
+        putLocIntoDest(p, d, p.module.consts[sym])
+    of skVar, skForVar, skLet:
       if {sfGlobal, sfThread} * sym.flags != {}:
         genVarPrototype(p.module, n)
 
-      if sym.loc.r == "" or sym.loc.t == nil:
-        #echo "FAILED FOR PRCO ", p.prc.name.s
-        #echo renderTree(p.prc.ast, {renderIds})
-        internalError p.config, n.info, "expr: var not init " & sym.name.s & "_" & $sym.id
       if sfThread in sym.flags:
         accessThreadLocalVar(p, sym)
         if emulatedThreadVars(p.config):
-          putIntoDest(p, d, sym.loc.lode, "NimTV_->" & sym.loc.r)
+          let loc {.cursor.} = p.module.globals[sym]
+          putIntoDest(p, d, loc.lode, "NimTV_->" & loc.r)
         else:
-          putLocIntoDest(p, d, sym.loc)
+          putLocIntoDest(p, d, p.module.globals[sym])
+      elif sfGlobal in sym.flags:
+        putLocIntoDest(p, d, p.module.globals[sym])
+      else: # must be a local then
+        putLocIntoDest(p, d, p.locals[sym])
+    of skResult:
+      # the 'result' location is either a parameter or local
+      if p.params[0].k != locNone:
+        putLocIntoDest(p, d, p.params[0])
       else:
-        putLocIntoDest(p, d, sym.loc)
+        putLocIntoDest(p, d, p.locals[sym])
     of skTemp:
-      when false:
-        # this is more harmful than helpful.
-        if sym.loc.r == "":
-          # we now support undeclared 'skTemp' variables for easier
-          # transformations in other parts of the compiler:
-          assignLocalVar(p, n)
-      if sym.loc.r == "" or sym.loc.t == nil:
-        #echo "FAILED FOR PRCO ", p.prc.name.s
-        #echo renderTree(p.prc.ast, {renderIds})
-        internalError(p.config, n.info, "expr: temp not init " & sym.name.s & "_" & $sym.id)
-      putLocIntoDest(p, d, sym.loc)
+      putLocIntoDest(p, d, p.locals[sym])
     of skParam:
-      if sym.loc.r == "" or sym.loc.t == nil:
-        # echo "FAILED FOR PRCO ", p.prc.name.s
-        # debug p.prc.typ.n
-        # echo renderTree(p.prc.ast, {renderIds})
-        internalError(p.config, n.info, "expr: param not init " & sym.name.s & "_" & $sym.id)
-      putLocIntoDest(p, d, sym.loc)
+      if sym.position + 1 < p.params.len:
+        putLocIntoDest(p, d, p.params[sym.position + 1])
+      else:
+        # must be the hidden environment parameter (which is treated as a
+        # local)
+        putLocIntoDest(p, d, p.locals[sym])
     else: internalError(p.config, n.info, "expr(" & $sym.kind & "); unknown symbol")
   of nkNilLit:
     if not isEmptyType(n.typ):
diff --git a/compiler/backend/ccgreset.nim b/compiler/backend/ccgreset.nim
index 9c1575603da..c5dc98757c4 100644
--- a/compiler/backend/ccgreset.nim
+++ b/compiler/backend/ccgreset.nim
@@ -30,9 +30,8 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
   of nkRecCase:
     p.config.internalAssert(n[0].kind == nkSym, n.info, "specializeResetN")
     let disc = n[0].sym
-    if disc.loc.r == "": fillObjectFields(p.module, typ)
-    p.config.internalAssert(disc.loc.t != nil, n.info, "specializeResetN()")
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.r])
+    ensureObjectFields(p.module, disc, typ)
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, p.fieldLoc(disc).r])
     for i in 1..<n.len:
       let branch = n[i]
       assert branch.kind in {nkOfBranch, nkElse}
@@ -43,13 +42,12 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
       specializeResetN(p, accessor, lastSon(branch), typ)
       lineF(p, cpsStmts, "break;$n", [])
     lineF(p, cpsStmts, "} $n", [])
-    specializeResetT(p, "$1.$2" % [accessor, disc.loc.r], disc.loc.t)
+    specializeResetT(p, "$1.$2" % [accessor, p.fieldLoc(disc).r], disc.typ)
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
-    if field.loc.r == "": fillObjectFields(p.module, typ)
-    p.config.internalAssert(field.loc.t != nil, n.info, "specializeResetN()")
-    specializeResetT(p, "$1.$2" % [accessor, field.loc.r], field.loc.t)
+    ensureObjectFields(p.module, field, typ)
+    specializeResetT(p, "$1.$2" % [accessor, p.fieldLoc(field).r], field.typ)
   else: internalError(p.config, n.info, "specializeResetN()")
 
 proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
diff --git a/compiler/backend/ccgstmts.nim b/compiler/backend/ccgstmts.nim
index f96c42afa8e..9d7a6ad4b90 100644
--- a/compiler/backend/ccgstmts.nim
+++ b/compiler/backend/ccgstmts.nim
@@ -169,7 +169,13 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
 
   if value.kind != nkEmpty:
     genLineDir(p, vn)
-    loadInto(p, vn, value, v.loc)
+    # we have an parameter aliasing issue here: passing `p.locals[v]`
+    # as the parameter directly would be an aliasing rule violation.
+    # Since the initializer expression cannot reference `v` itself,
+    # it's safe to temporarily move the loc out of ``p.locals``
+    var loc = move p.locals[v]
+    loadInto(p, vn, value, loc)
+    p.locals.assign(v, loc) # put it back
 
 proc genSingleVar(p: BProc, a: PNode) =
   let v = a[0].sym
@@ -355,7 +361,6 @@ proc genBlock(p: BProc, n: PNode) =
       # named block?
       assert(n[0].kind == nkSym)
       var sym = n[0].sym
-      sym.loc.k = locOther
       sym.position = p.breakIdx+1
     genStmts(p, n[1])
     endBlock(p)
@@ -366,7 +371,7 @@ proc genBreakStmt(p: BProc, t: PNode) =
     # named break?
     assert(t[0].kind == nkSym)
     var sym = t[0].sym
-    doAssert(sym.loc.k == locOther)
+    doAssert(sym.kind == skLabel)
     idx = sym.position-1
   else:
     # an unnamed 'break' can only break a loop after 'transf' pass:
@@ -745,16 +750,9 @@ proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false): Rope =
       of skField:
         # special support for raw field symbols
         discard getTypeDesc(p.module, skipTypes(sym.typ, abstractPtrs))
-        var r = sym.loc.r
-        if r == "":
-          # problem: a field doesn't know what type it is part of, so we
-          # can neither use ``fillObjectFields`` nor a ``FieldX`` name
-          # (in the case of tuples). To make sure that the mangled name is
-          # at  least correct for object types, we always use field name
-          # mangling
-          r = mangleRecFieldName(p.module, sym)
-          sym.loc.r = r       # but be consequent!
-        res.add(r)
+        p.config.internalAssert(sym.locId != 0, it.info):
+          "field's surrounding type not setup"
+        res.add(p.fieldLoc(sym).r)
       else:
         unreachable(sym.kind)
     of nkType:
diff --git a/compiler/backend/ccgthreadvars.nim b/compiler/backend/ccgthreadvars.nim
index 32e0431d637..704eeaa4650 100644
--- a/compiler/backend/ccgthreadvars.nim
+++ b/compiler/backend/ccgthreadvars.nim
@@ -29,16 +29,16 @@ proc declareThreadVar*(m: BModule, s: PSym, isExtern: bool) =
     # storage for that somehow, can't use the thread local storage
     # allocator for it :-(
     if not containsOrIncl(m.g.nimtvDeclared, s.id):
-      m.g.nimtvDeps.add(s.loc.t)
-      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.loc.t), s.loc.r])
+      m.g.nimtvDeps.add(s.typ)
+      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.typ), m.globals[s].r])
   else:
     if isExtern: m.s[cfsVars].add("extern ")
     elif lfExportLib in s.loc.flags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
     else: m.s[cfsVars].add("N_LIB_PRIVATE ")
     if optThreads in m.config.globalOptions:
       m.s[cfsVars].add("NIM_THREADVAR ")
-    m.s[cfsVars].add(getTypeDesc(m, s.loc.t))
-    m.s[cfsVars].addf(" $1;$n", [s.loc.r])
+    m.s[cfsVars].add(getTypeDesc(m, s.typ))
+    m.s[cfsVars].addf(" $1;$n", [m.globals[s].r])
 
 proc generateThreadLocalStorage(m: BModule) =
   if m.g.nimtv != "" and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
diff --git a/compiler/backend/ccgtypes.nim b/compiler/backend/ccgtypes.nim
index 964ee5bd300..5d2109e0701 100644
--- a/compiler/backend/ccgtypes.nim
+++ b/compiler/backend/ccgtypes.nim
@@ -41,8 +41,6 @@ proc mangleName(m: BModule; s: PSym): Rope =
     result.add m.g.graph.ifaces[s.itemId.module].uniqueName
     result.add "_"
     result.add rope s.itemId.item
-    s.loc.r = result
-    writeMangledName(m.ndi, s, m.config)
 
 proc mangleParamName(m: BModule; s: PSym): Rope =
   ## we cannot use 'sigConflicts' here since we have a BModule, not a BProc.
@@ -55,8 +53,6 @@ proc mangleParamName(m: BModule; s: PSym): Rope =
       res.add "_0"
 
     result = res.rope
-    s.loc.r = result
-    writeMangledName(m.ndi, s, m.config)
 
 proc mangleLocalName(p: BProc; s: PSym): Rope =
   assert s.kind in skLocalVars+{skTemp}
@@ -73,8 +69,6 @@ proc mangleLocalName(p: BProc; s: PSym): Rope =
     elif counter != 0 or isKeyword(s.name) or p.module.g.config.cppDefines.contains(key):
       result.add "_" & rope(counter+1)
     p.sigConflicts.inc(key)
-    s.loc.r = result
-    if s.kind != skTemp: writeMangledName(p.module.ndi, s, p.config)
 
 proc scopeMangledParam(p: BProc; param: PSym) =
   ## parameter generation only takes BModule, not a BProc, so we have to
@@ -108,14 +102,7 @@ proc getTypeName(m: BModule; typ: PType; sig: SigHash): Rope =
     else:
       break
   let typ = if typ.kind in {tyAlias, tySink}: typ.lastSon else: typ
-  if typ.loc.r == "":
-    typ.loc.r = typ.typeName & $sig
-  else:
-    when defined(debugSigHashes):
-      # check consistency:
-      assert($typ.loc.r == $(typ.typeName & $sig))
-  result = typ.loc.r
-  m.config.internalAssert(result != "", "getTypeName: " & $typ.kind)
+  result = typ.typeName & $sig
 
 proc mapSetType(conf: ConfigRef; typ: PType): TCTypeKind =
   case int(getSize(conf, typ))
@@ -227,13 +214,12 @@ proc addAbiCheck(m: BModule, t: PType, name: Rope) =
     # see `testCodegenABICheck` for example error message it generates
 
 
-proc fillResult(conf: ConfigRef; param: PNode) =
-  fillLoc(param.sym.loc, locParam, param, ~"Result",
-          OnStack)
+proc initResultParamLoc(conf: ConfigRef; param: PNode): TLoc =
+  result = initLoc(locParam, param, "Result", OnStack)
   let t = param.sym.typ
   if mapReturnType(conf, t) != ctArray and isInvalidReturnType(conf, t):
-    incl(param.sym.loc.flags, lfIndirect)
-    param.sym.loc.storage = OnUnknown
+    incl(result.flags, lfIndirect)
+    result.storage = OnUnknown
 
 proc typeNameOrLiteral(m: BModule; t: PType, literal: string): Rope =
   if t.sym != nil and sfImportc in t.sym.flags and t.sym.magic == mNone:
@@ -368,17 +354,20 @@ struct $2_Content { NI cap; $1 data[SEQ_DECL_SIZE];};
 $3endif$N
       """, [getTypeDescAux(m, t.skipTypes(abstractInst)[0], check, skVar), result, rope"#"])
 
-proc prepareParameters(m: BModule, t: PType) =
-  ## Prepares the locs of the parameter symbols for procedure type `t`.
+proc prepareParameters(m: BModule, t: PType): seq[TLoc] =
+  ## Sets up and returns the locs of the parameter symbols for procedure
+  ## type `t`. The loc for the first parameter is stored at index 1.
   ##
   ## Neither the loc for the 'result' nor for the hidden environment parameter
   ## are filled-in here. 'result' might not be a parameter, and the hidden
   ## environment parameter is currently always treated as a local variable.
   assert t.kind == tyProc
   let params = t.n
+  result.newSeq(params.len)
+
   for i in 1..<params.len:
     let param = params[i].sym
-    if isCompileTimeOnly(param.typ) or param.loc.k != locNone:
+    if isCompileTimeOnly(param.typ):
       # ignore parameters only relevant for overloading (e.g., ``static[T]``,
       # etc.); already filled-in parameters are also skipped
       continue
@@ -391,17 +380,17 @@ proc prepareParameters(m: BModule, t: PType) =
       else:
         OnStack
 
-    fillLoc(param.loc, locParam, params[i], mangleParamName(m, param),
-            storage)
+    result[i] = initLoc(locParam, params[i], mangleParamName(m, param),
+                        storage)
 
     if ccgIntroducedPtr(m.config, param, t[0]):
       # the parameter is passed by address; mark it as indirect
-      incl(param.loc.flags, lfIndirect)
-      param.loc.storage = OnUnknown
+      incl(result[i].flags, lfIndirect)
+      result[i].storage = OnUnknown
 
 proc genProcParams(m: BModule, t: PType, rettype, params: var Rope,
-                   check: var IntSet, declareEnvironment=true;
-                   weakDep=false) =
+                   check: var IntSet, locs: openArray[TLoc],
+                   declareEnvironment=true; weakDep=false) =
   params = ""
   if t[0] == nil or isInvalidReturnType(m.config, t[0]):
     rettype = ~"void"
@@ -410,9 +399,9 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var Rope,
   for i in 1..<t.n.len:
     m.config.internalAssert(t.n[i].kind == nkSym, t.n.info, "genProcParams")
     var param = t.n[i].sym
-    if param.loc.k == locNone: continue
+    if locs[i].k == locNone: continue
     if params != "": params.add(~", ")
-    if lfIndirect in param.loc.flags:
+    if lfIndirect in locs[i].flags:
       params.add(getTypeDescWeak(m, param.typ, check, skParam))
       params.add(~"*")
     elif weakDep:
@@ -422,14 +411,14 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var Rope,
     params.add(~" ")
     if sfNoalias in param.flags:
       params.add(~"NIM_NOALIAS ")
-    params.add(param.loc.r)
+    params.add(locs[i].r)
     # declare the len field for open arrays:
     var arr = param.typ.skipTypes({tyGenericInst})
     if arr.kind in {tyVar, tyLent, tySink}: arr = arr.lastSon
     var j = 0
     while arr.kind in {tyOpenArray, tyVarargs}:
       # need to pass hidden parameter:
-      params.addf(", NI $1Len_$2", [param.loc.r, j.rope])
+      params.addf(", NI $1Len_$2", [locs[i].r, j.rope])
       inc(j)
       arr = arr[0].skipTypes({tySink})
   if t[0] != nil and isInvalidReturnType(m.config, t[0]):
@@ -501,35 +490,46 @@ proc genRecordFieldsAux(m: BModule, n: PNode,
     if field.typ.kind == tyVoid: return
     #assert(field.ast == nil)
     let sname = mangleRecFieldName(m, field)
-    fillLoc(field.loc, locField, n, unionPrefix & sname, OnUnknown)
+    if field.locId == 0:
+      # XXX: the C struct definition for the type is re-generated in every C
+      #      file the type is used in, so the field might have an associated
+      #      loc. Eventually, each C type is only generated once, and then the
+      #      guard can be removed
+      m.fields.put(field):
+        initLoc(locField, n, unionPrefix & sname, OnUnknown)
+
     if field.alignment > 0:
       result.addf "NIM_ALIGN($1) ", [rope(field.alignment)]
     let noAlias = if sfNoalias in field.flags: " NIM_NOALIAS" else: ""
 
-    let fieldType = field.loc.lode.typ.skipTypes(abstractInst)
+    let fieldType = field.typ.skipTypes(abstractInst)
     if fieldType.kind == tyUncheckedArray:
       result.addf("$1 $2[SEQ_DECL_SIZE];$n",
           [getTypeDescAux(m, fieldType.elemType, check, skField), sname])
     elif fieldType.kind == tySequence:
       # we need to use a weak dependency here for trecursive_table.
-      result.addf("$1$3 $2;$n", [getTypeDescWeak(m, field.loc.t, check, skField), sname, noAlias])
+      result.addf("$1$3 $2;$n", [getTypeDescWeak(m, field.typ, check, skField), sname, noAlias])
     elif field.bitsize != 0:
-      result.addf("$1$4 $2:$3;$n", [getTypeDescAux(m, field.loc.t, check, skField), sname, rope($field.bitsize), noAlias])
+      result.addf("$1$4 $2:$3;$n", [getTypeDescAux(m, field.typ, check, skField), sname, rope($field.bitsize), noAlias])
     else:
       # TODO: C++ remove
       # don't use fieldType here because we need the
       # tyGenericInst for C++ template support
-      result.addf("$1$3 $2;$n", [getTypeDescAux(m, field.loc.t, check, skField), sname, noAlias])
+      result.addf("$1$3 $2;$n", [getTypeDescAux(m, field.typ, check, skField), sname, noAlias])
   else: internalError(m.config, n.info, "genRecordFieldsAux()")
 
 proc getRecordFields(m: BModule, typ: PType, check: var IntSet): Rope =
   result = genRecordFieldsAux(m, typ.n, typ, check)
 
-proc fillObjectFields*(m: BModule; typ: PType) =
-  # sometimes generic objects are not consistently merged. We patch over
-  # this fact here.
-  var check = initIntSet()
-  discard getRecordFields(m, typ, check)
+proc ensureObjectFields*(m: BModule; field: PSym, typ: PType) =
+  ## Two different object types can produce the same signature hash in
+  ## certain cases (the hidden parameter type of a generic's inner procedure,
+  ## for example), in which case ``getTypeDescAux`` never calls
+  ## ``genRecordDesc``. This procedures makes sure that the field has a valid
+  ## loc.
+  if field.locId == 0:
+    var check = initIntSet()
+    discard getRecordFields(m, typ, check)
 
 proc mangleDynLibProc(sym: PSym): Rope
 
@@ -687,8 +687,8 @@ proc getTypeDescAux(m: BModule, origTyp: PType, check: var IntSet; kind: TSymKin
     result = getTypeName(m, origTyp, sig)
     m.typeCache[sig] = result
     var rettype, desc: Rope
-    prepareParameters(m, t)
-    genProcParams(m, t, rettype, desc, check, true, true)
+    let params = prepareParameters(m, t)
+    genProcParams(m, t, rettype, desc, check, params, true, true)
     if not isImportedType(t):
       if t.callConv != ccClosure: # procedure vars may need a closure!
         m.s[cfsTypes].addf("typedef $1_PTR($2, $3) $4;$n",
@@ -764,9 +764,9 @@ proc getClosureType(m: BModule, t: PType, kind: TClosureTypeKind): Rope =
   assert t.kind == tyProc
   var check = initIntSet()
   result = getTempName(m)
+  let params = prepareParameters(m, t)
   var rettype, desc: Rope
-  prepareParameters(m, t)
-  genProcParams(m, t, rettype, desc, check, declareEnvironment=kind != clHalf)
+  genProcParams(m, t, rettype, desc, check, params, declareEnvironment=kind != clHalf)
   if not isImportedType(t):
     if t.callConv != ccClosure or kind != clFull:
       m.s[cfsTypes].addf("typedef $1_PTR($2, $3) $4;$n",
@@ -789,7 +789,9 @@ proc finishTypeDescriptions(m: BModule) =
     inc(i)
   m.typeStack.setLen 0
 
-proc genProcHeader(m: BModule, prc: PSym): Rope =
+proc genProcHeader(m: BModule, prc: PSym, locs: openArray[TLoc]): Rope =
+  ## Generates the C function header for `prc`, with `locs` being the locs
+  ## of the formal parameters.
   var
     rettype, params: Rope
   # using static is needed for inline procs
@@ -803,15 +805,13 @@ proc genProcHeader(m: BModule, prc: PSym): Rope =
   elif sfImportc notin prc.flags:
     result.add "N_LIB_PRIVATE "
   var check = initIntSet()
-  fillLoc(prc.loc, locProc, prc.ast[namePos], mangleName(m, prc), OnUnknown)
-  prepareParameters(m, prc.typ)
-  genProcParams(m, prc.typ, rettype, params, check)
+  genProcParams(m, prc.typ, rettype, params, check, locs)
 
-  let name = prc.loc.r
   # careful here! don't access ``prc.ast`` as that could reload large parts of
   # the object graph!
   result.addf("$1($2, $3)$4",
-        [rope(CallingConvToStr[prc.typ.callConv]), rettype, name, params])
+        [rope(CallingConvToStr[prc.typ.callConv]), rettype, m.procs[prc].loc.r,
+         params])
 
 # ------------------ type info generation -------------------------------------
 
@@ -909,12 +909,12 @@ proc genObjectFields(m: BModule, typ, origType: PType, n: PNode, expr: Rope;
     var tmp = discriminatorTableName(m, typ, field)
     var L = lengthOrd(m.config, field.typ)
     assert L > 0
-    if field.loc.r == "": fillObjectFields(m, typ)
-    m.config.internalAssert(field.loc.t != nil, n.info, "genObjectFields")
+    ensureObjectFields(m, field, typ)
     m.s[cfsTypeInit3].addf("$1.kind = 3;$n" &
         "$1.offset = offsetof($2, $3);$n" & "$1.typ = $4;$n" &
         "$1.name = $5;$n" & "$1.sons = &$6[0];$n" &
-        "$1.len = $7;$n", [expr, getTypeDesc(m, origType, skVar), field.loc.r,
+        "$1.len = $7;$n", [expr, getTypeDesc(m, origType, skVar),
+                           m.fields[field].r,
                            genTypeInfoV1(m, field.typ, info),
                            makeCString(field.name.s),
                            tmp, rope(L)])
@@ -945,12 +945,12 @@ proc genObjectFields(m: BModule, typ, origType: PType, n: PNode, expr: Rope;
     # Do not produce code for void types
     if isEmptyType(field.typ): return
     if field.bitsize == 0:
-      if field.loc.r == "": fillObjectFields(m, typ)
-      m.config.internalAssert(field.loc.t != nil, n.info, "genObjectFields")
+      ensureObjectFields(m, field, typ)
       m.s[cfsTypeInit3].addf("$1.kind = 1;$n" &
           "$1.offset = offsetof($2, $3);$n" & "$1.typ = $4;$n" &
           "$1.name = $5;$n", [expr, getTypeDesc(m, origType, skVar),
-          field.loc.r, genTypeInfoV1(m, field.typ, info), makeCString(field.name.s)])
+          m.fields[field].r, genTypeInfoV1(m, field.typ, info),
+          makeCString(field.name.s)])
   else: internalError(m.config, n.info, "genObjectFields")
 
 proc genObjectInfo(m: BModule, typ, origType: PType, name: Rope; info: TLineInfo) =
@@ -1058,7 +1058,7 @@ proc genDeepCopyProc(m: BModule; s: PSym; result: Rope) =
   useProc(m, s)
   m.g.hooks.add (m, s)
   m.s[cfsTypeInit3].addf("$1.deepcopy =(void* (N_RAW_NIMCALL*)(void*))$2;$n",
-     [result, s.loc.r])
+     [result, m.procs[s].loc.r])
 
 proc declareNimType(m: BModule, name: string; str: Rope, module: int) =
   m.s[cfsData].addf("extern $2 $1;$n", [str, rope(name)])
@@ -1101,7 +1101,7 @@ proc genHook(m: BModule; t: PType; info: TLineInfo; op: TTypeAttachedOp): Rope =
     useProc(m, theProc)
     m.g.hooks.add (m, theProc)
 
-    result = theProc.loc.r
+    result = m.procs[theProc].loc.r
 
     when false:
       if not canFormAcycle(t) and op == attachedTrace:
diff --git a/compiler/backend/cgen.nim b/compiler/backend/cgen.nim
index fd730a451eb..bf8f4f0802c 100644
--- a/compiler/backend/cgen.nim
+++ b/compiler/backend/cgen.nim
@@ -116,6 +116,9 @@ proc initLoc(result: var TLoc, k: TLocKind, lode: PNode, s: TStorageLoc) =
   result.r = ""
   result.flags = {}
 
+func initLoc(kind: TLocKind, n: PNode, name: sink string, storage: TStorageLoc): TLoc =
+  TLoc(k: kind, storage: storage, lode: n, r: name, flags: {})
+
 proc fillLoc(a: var TLoc, k: TLocKind, lode: PNode, r: Rope, s: TStorageLoc) =
   ## fills the loc if it is not already initialized
   if a.k == locNone:
@@ -463,7 +466,7 @@ proc initLocalVar(p: BProc, v: PSym, immediateAsgn: bool) =
     # ``var v = X()`` gets transformed into ``X(&v)``.
     # Nowadays the logic in ccgcalls deals with this case however.
     if not immediateAsgn:
-      constructLoc(p, v.loc)
+      constructLoc(p, p.locals[v])
 
 proc getTemp(p: BProc, t: PType, result: var TLoc; needsInit=false) =
   inc(p.labels)
@@ -494,8 +497,7 @@ proc getIntTemp(p: BProc, result: var TLoc) =
 
 proc localVarDecl(p: BProc; n: PNode): Rope =
   let s = n.sym
-  if s.loc.k == locNone:
-    fillLoc(s.loc, locLocalVar, n, mangleLocalName(p, s), OnStack)
+  let loc = initLoc(locLocalVar, n, mangleLocalName(p, s), OnStack)
   if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
     result.addf("NIM_ALIGN($1) ", [rope(s.alignment)])
   result.add getTypeDesc(p.module, s.typ, skVar)
@@ -506,12 +508,21 @@ proc localVarDecl(p: BProc; n: PNode): Rope =
     if sfVolatile in s.flags: result.add(" volatile")
     if sfNoalias in s.flags: result.add(" NIM_NOALIAS")
     result.add(" ")
-    result.add(s.loc.r)
+    result.add(loc.r)
+
+  # XXX: inline procedure are generated multiple times, so the symbol can
+  #      already have a non-zero ``locId``
+  if s notin p.locals:
+    p.locals.forcePut(s, loc)
+  else:
+    # XXX: finally blocks are duplicated by the code generator, so we have to
+    #      be lenient here and allow the local already existing. This is a bad
+    #      idea, however; if finally clauses are implemented via code
+    #      duplication, then that duplication needs to happen prior to code
+    #      generation
+    p.locals.assign(s, loc)
 
 proc assignLocalVar(p: BProc, n: PNode) =
-  #assert(s.loc.k == locNone) # not yet assigned
-  # this need not be fulfilled for inline procs; they are regenerated
-  # for each module that uses them!
   let nl = if optLineDir in p.config.options: "" else: "\L"
   let decl = localVarDecl(p, n) & ";" & nl
   line(p, cpsLocals, decl)
@@ -521,12 +532,11 @@ include ccgthreadvars
 proc varInDynamicLib(m: BModule, sym: PSym)
 
 proc fillGlobalLoc*(m: BModule, s: PSym, n: PNode) =
-  fillLoc(s.loc, locGlobalVar, n, mangleName(m, s), OnHeap)
+  m.globals.put(s, initLoc(locGlobalVar, n, mangleName(m, s), OnHeap))
 
 proc defineGlobalVar*(m: BModule, n: PNode) =
   let s = n.sym
-  if s.loc.k == locNone:
-    fillGlobalLoc(m, s, n)
+  fillGlobalLoc(m, s, n)
 
   assert s.id notin m.declaredThings
   assert findPendingModule(m, s) == m, "not the attached-to module"
@@ -539,7 +549,7 @@ proc defineGlobalVar*(m: BModule, n: PNode) =
     if lfNoDecl notin s.loc.flags:
       incl(m.declaredThings, s.id)
       var decl = ""
-      var td = getTypeDesc(m, s.loc.t, skVar)
+      var td = getTypeDesc(m, m.globals[s].t, skVar)
       if true:
         if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
           decl.addf "NIM_ALIGN($1) ", [rope(s.alignment)]
@@ -550,21 +560,15 @@ proc defineGlobalVar*(m: BModule, n: PNode) =
         if sfRegister in s.flags: decl.add(" register")
         if sfVolatile in s.flags: decl.add(" volatile")
         if sfNoalias in s.flags: decl.add(" NIM_NOALIAS")
-        decl.addf(" $1;$n", [s.loc.r])
+        decl.addf(" $1;$n", [m.globals[s].r])
 
       m.s[cfsVars].add(decl)
 
-proc assignParam(p: BProc, s: PSym, retType: PType) =
-  assert(s.loc.r != "")
-  scopeMangledParam(p, s)
-
-proc fillProcLoc(n: PNode, name: Rope) {.inline.} =
-  fillLoc(n.sym.loc, locProc, n, name, OnStack)
-
 proc fillProcLoc*(m: BModule; n: PNode) =
   let sym = n.sym
-  if sym.loc.k == locNone:
-    fillProcLoc(n, mangleName(m, sym))
+  if sym.locId == 0:
+    m.procs.put(sym):
+      (initLoc(locProc, n, mangleName(m, sym), OnStack), (seq[TLoc])(@[]))
 
 proc getLabel(p: BProc): TLabel =
   inc(p.labels)
@@ -688,8 +692,10 @@ proc symInDynamicLib*(m: BModule, sym: PSym) =
   let isCall = isGetProcAddr(lib)
   var extname = sym.loc.r
   if not isCall: loadDynamicLib(m, lib)
-  var tmp = mangleDynLibProc(sym)
-  sym.loc.r = tmp             # from now on we only need the internal name
+  let tmp = mangleDynLibProc(sym)
+  # XXX: dynlib procedures should be treated as globals here (because that's
+  #      what they are, really)
+  m.procs[sym].loc.r = tmp    # from now on we only need the internal name
   sym.typ.sym = nil           # generate a new name
   inc(m.labels, 2)
   if isCall:
@@ -718,28 +724,28 @@ proc symInDynamicLib*(m: BModule, sym: PSym) =
     appcg(m, m.s[cfsDynLibInit],
         "\t$1 = ($2) #nimGetProcAddr($3, $4);$n",
         [tmp, getTypeDesc(m, sym.typ, skVar), lib.name, makeCString($extname)])
-  m.s[cfsVars].addf("$2 $1;$n", [sym.loc.r, getTypeDesc(m, sym.loc.t, skVar)])
+  m.s[cfsVars].addf("$2 $1;$n", [tmp, getTypeDesc(m, sym.typ, skVar)])
 
 proc varInDynamicLib(m: BModule, sym: PSym) =
   var lib = sym.annex
   var extname = sym.loc.r
   loadDynamicLib(m, lib)
-  incl(sym.loc.flags, lfIndirect)
-  var tmp = mangleDynLibProc(sym)
-  sym.loc.r = tmp             # from now on we only need the internal name
+  let tmp = mangleDynLibProc(sym)
+  incl(m.globals[sym].flags, lfIndirect)
+  m.globals[sym].r = tmp  # from now on we only need the internal name
   inc(m.labels, 2)
   appcg(m, m.s[cfsDynLibInit],
       "$1 = ($2*) #nimGetProcAddr($3, $4);$n",
       [tmp, getTypeDesc(m, sym.typ, skVar), lib.name, makeCString($extname)])
   m.s[cfsVars].addf("$2* $1;$n",
-      [sym.loc.r, getTypeDesc(m, sym.loc.t, skVar)])
+      [tmp, getTypeDesc(m, sym.typ, skVar)])
 
 proc cgsym(m: BModule, name: string): Rope =
   let sym = magicsys.getCompilerProc(m.g.graph, name)
   if sym != nil:
     case sym.kind
     of skProc, skFunc, skMethod, skConverter, skIterator:
-      genProcPrototype(m, sym) # emit a prototype
+      useProc(m, sym)
       m.extra.add(sym) # notify the caller about the dependency
     of skVar, skResult, skLet: genVarPrototype(m, newSymNode sym)
     of skType: discard getTypeDesc(m, sym.typ)
@@ -787,7 +793,7 @@ proc closureSetup(p: BProc, prc: PSym) =
   assignLocalVar(p, ls)
   # generate cast assignment:
   linefmt(p, cpsStmts, "$1 = ($2) ClE_0;$n",
-          [rdLoc(env.loc), getTypeDesc(p.module, env.typ)])
+          [rdLoc(p.locals[env]), getTypeDesc(p.module, env.typ)])
 
 proc containsResult(n: PNode): bool =
   result = false
@@ -914,7 +920,10 @@ proc isNoReturn(m: BModule; s: PSym): bool {.inline.} =
 proc startProc*(m: BModule, prc: PSym; procBody: PNode = nil): BProc =
   var p = newProc(prc, m)
   assert(prc.ast != nil)
-  prepareParameters(m, prc.typ)
+  fillProcLoc(m, prc.ast[namePos]) # ensure that a loc exists
+  if m.procs[prc].params.len == 0:
+    # if a prototype was emitted, the parameter list already exists
+    m.procs[prc].params = prepareParameters(m, prc.typ)
 
   if sfPure notin prc.flags and prc.typ[0] != nil:
     m.config.internalAssert(resultPos < prc.ast.len, prc.info, "proc has no result symbol")
@@ -924,11 +933,10 @@ proc startProc*(m: BModule, prc: PSym; procBody: PNode = nil): BProc =
       if sfNoInit in prc.flags: incl(res.flags, sfNoInit)
       # declare the result symbol:
       assignLocalVar(p, resNode)
-      assert(res.loc.r != "")
       initLocalVar(p, res, immediateAsgn=false)
     else:
-      fillResult(p.config, resNode)
-      assignParam(p, res, prc.typ[0])
+      p.params[0] = initResultParamLoc(p.config, resNode)
+      scopeMangledParam(p, res)
       # We simplify 'unsureAsgn(result, nil); unsureAsgn(result, x)'
       # to 'unsureAsgn(result, x)'
       # Sketch why this is correct: If 'result' points to a stack location
@@ -939,10 +947,10 @@ proc startProc*(m: BModule, prc: PSym; procBody: PNode = nil): BProc =
       elif procBody != nil and
            allPathsAsgnResult(procBody) == InitSkippable: discard
       else:
-        resetLoc(p, res.loc)
+        resetLoc(p, p.params[0])
       if skipTypes(res.typ, abstractInst).kind == tyArray:
         #incl(res.loc.flags, lfIndirect)
-        res.loc.storage = OnUnknown
+        p.params[0].storage = OnUnknown
 
   # for now, we treat all compilerprocs as being able to run in a boot
   # environment where the error flag is not yet accessible. This is not quite
@@ -958,8 +966,8 @@ proc startProc*(m: BModule, prc: PSym; procBody: PNode = nil): BProc =
 
   for i in 1..<prc.typ.n.len:
     let param = prc.typ.n[i].sym
-    if param.loc.k == locNone: continue
-    assignParam(p, param, prc.typ[0])
+    if p.params[i].k == locNone: continue
+    scopeMangledParam(p, param)
   closureSetup(p, prc)
 
   if sfPure notin prc.flags and optStackTrace in prc.options:
@@ -978,12 +986,12 @@ proc finishProc*(p: BProc, prc: PSym): string =
     p.blocks[0].sections[cpsInit].add(ropecg(p.module, "nimErr_ = #nimErrorFlag();$n", []))
 
   var
-    header = genProcHeader(p.module, prc)
+    header = genProcHeader(p.module, prc, p.params)
     returnStmt = ""
 
   if sfPure notin prc.flags and not isInvalidReturnType(p.config, prc.typ[0]):
     returnStmt = ropecg(p.module, "\treturn $1;$n",
-                        [rdLoc(prc.ast[resultPos].sym.loc)])
+                        [rdLoc(p.locals[prc.ast[resultPos].sym])])
 
   var generatedProc: Rope
   generatedProc.genCLineDir prc.info, p.config
@@ -1037,10 +1045,12 @@ proc genProcPrototype(m: BModule, sym: PSym) =
         not containsOrIncl(m.declaredThings, sym.id):
       m.s[cfsVars].add(ropecg(m, "$1 $2 $3;$n",
                         ["extern",
-                        getTypeDesc(m, sym.loc.t), mangleDynLibProc(sym)]))
+                        getTypeDesc(m, m.procs[sym].loc.t), mangleDynLibProc(sym)]))
 
   elif not containsOrIncl(m.declaredProtos, sym.id):
-    var header = genProcHeader(m, sym)
+    if m.procs[sym].params.len == 0:
+      m.procs[sym].params = prepareParameters(m, sym.typ)
+    var header = genProcHeader(m, sym, m.procs[sym].params)
     block:
       if isNoReturn(m, sym) and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
         header = "__declspec(noreturn) " & header
@@ -1068,13 +1078,10 @@ proc genVarPrototype(m: BModule, n: PNode) =
   #assert(sfGlobal in sym.flags)
   let sym = n.sym
   useHeader(m, sym)
-  fillLoc(sym.loc, locGlobalVar, n, mangleName(m, sym), OnHeap)
-
   if (lfNoDecl in sym.loc.flags) or contains(m.declaredThings, sym.id):
     return
   if sym.owner.id != m.module.id:
     # else we already have the symbol generated!
-    assert(sym.loc.r != "")
     if sfThread in sym.flags:
       declareThreadVar(m, sym, true)
     else:
@@ -1082,12 +1089,12 @@ proc genVarPrototype(m: BModule, n: PNode) =
       if sym.kind in {skLet, skVar, skField, skForVar} and sym.alignment > 0:
         m.s[cfsVars].addf "NIM_ALIGN($1) ", [rope(sym.alignment)]
       m.s[cfsVars].add("extern ")
-      m.s[cfsVars].add(getTypeDesc(m, sym.loc.t, skVar))
+      m.s[cfsVars].add(getTypeDesc(m, sym.typ, skVar))
       if lfDynamicLib in sym.loc.flags: m.s[cfsVars].add("*")
       if sfRegister in sym.flags: m.s[cfsVars].add(" register")
       if sfVolatile in sym.flags: m.s[cfsVars].add(" volatile")
       if sfNoalias in sym.flags: m.s[cfsVars].add(" NIM_NOALIAS")
-      m.s[cfsVars].addf(" $1;$n", [sym.loc.r])
+      m.s[cfsVars].addf(" $1;$n", [m.globals[sym].r])
 
 proc addNimDefines(result: var Rope; conf: ConfigRef) {.inline.} =
   result.addf("#define NIM_INTBITS $1\L", [
diff --git a/compiler/backend/cgendata.nim b/compiler/backend/cgendata.nim
index 29e89570eb2..3895ad2fbf6 100644
--- a/compiler/backend/cgendata.nim
+++ b/compiler/backend/cgendata.nim
@@ -27,12 +27,24 @@ import
     options
   ],
   compiler/utils/[
+    containers,
     ropes,
     pathutils
   ]
 
 
 type
+  SymbolMap*[T] = object
+    ## Associates extra location-related data with symbols. This is
+    ## temporary scaffolding until each entity (type, local, procedure,
+    ## etc.) is consistently represented as an index-like handle in the
+    ## code generator, at which point a ``Store`` (or ``SeqMap``) can be
+    ## used directly.
+    ##
+    ## Mapping from a symbol to the associated data currently happens via
+    ## ``TSym.locId``.
+    store: Store[range[0'u32..high(uint32)-1], T]
+
   TLabel* = Rope              ## for the C generator a label is just a rope
   TCFileSection* = enum       ## the sections a generated C file consists of
     cfsMergeInfo,             ## section containing merge information
@@ -114,6 +126,8 @@ type
     withinBlockLeaveActions*: int ## complex to explain
     sigConflicts*: CountTable[string]
 
+    locals*: SymbolMap[TLoc]  ## the locs for all locals of the procedure
+
   TTypeSeq* = seq[PType]
   TypeCache* = Table[SigHash, Rope]
   TypeCacheWithOwner* = Table[SigHash, tuple[str: Rope, owner: int32]]
@@ -147,6 +161,16 @@ type
                             ## nimtvDeps is VERY hard to cache because it's
                             ## not a list of IDs nor can it be made to be one.
 
+    globals*: SymbolMap[TLoc]
+      ## the locs for all alive globals of the program
+    consts*: SymbolMap[TLoc]
+      ## the locs for all alive constants of the program
+    procs*: SymbolMap[tuple[loc: TLoc, params: seq[TLoc]]]
+      ## the locs for all alive procedure of the program. Also stores the
+      ## locs for the parameters
+    fields*: SymbolMap[TLoc]
+      ## the locs for all fields
+
     hooks*: seq[(BModule, PSym)]
       ## late late-dependencies. Generating code for a procedure might lead
       ## to the RTTI setup code for some type from a foreign module (i.e., one
@@ -196,6 +220,20 @@ type
 template config*(m: BModule): ConfigRef = m.g.config
 template config*(p: BProc): ConfigRef = p.module.g.config
 
+template procs*(m: BModule): untyped   = m.g.procs
+template fields*(m: BModule): untyped  = m.g.fields
+template globals*(m: BModule): untyped = m.g.globals
+template consts*(m: BModule): untyped  = m.g.consts
+
+template fieldLoc*(p: BProc, field: PSym): TLoc =
+  ## Returns the loc for the given `field`.
+  p.module.fields[field]
+
+template params*(p: BProc): seq[TLoc] =
+  ## Returns the mutable list with the locs of `p`'s
+  ## parameters.
+  p.module.procs[p.prc].params
+
 proc includeHeader*(this: BModule; header: string) =
   if not this.headerFiles.contains header:
     this.headerFiles.add header
@@ -226,3 +264,33 @@ iterator cgenModules*(g: BModuleList): BModule =
   for m in g.modulesClosed:
     # iterate modules in the order they were closed
     yield m
+
+func put*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.}  =
+  ## Adds `it` to `m` and registers a mapping between the item and
+  ## `sym`. `sym` must have no mapping registered yet.
+  assert sym.locId == 0, "symbol already registered"
+  sym.locId = uint32(m.store.add(it)) + 1
+
+func forcePut*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.} =
+  ## Adds `it` to `m` and register a mapping between the item and
+  ## `sym`, overwriting any existing mappings of `sym`.
+  sym.locId = uint32(m.store.add(it)) + 1
+
+func assign*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.}  =
+  ## Sets the value of the item in `m` with which `sym` is associated. This is
+  ## only meant as a workaround.
+  assert sym.locId > 0
+  m.store[sym.locId - 1] = it
+
+func `[]`*[T](m: SymbolMap[T], sym: PSym): lent T {.inline.} =
+  m.store[sym.locId - 1]
+
+func `[]`*[T](m: var SymbolMap[T], sym: PSym): var T {.inline.} =
+  m.store[sym.locId - 1]
+
+func contains*[T](m: SymbolMap[T], sym: PSym): bool {.inline.} =
+  sym.locId > 0 and m.store.nextId().uint32 > sym.locId - 1
+
+iterator items*[T](m: SymbolMap[T]): lent T =
+  for it in m.store.items:
+    yield it
\ No newline at end of file
diff --git a/compiler/utils/containers.nim b/compiler/utils/containers.nim
index ee24926c37b..3950d1281e0 100644
--- a/compiler/utils/containers.nim
+++ b/compiler/utils/containers.nim
@@ -107,6 +107,11 @@ iterator pairs*[I, T](x: Store[I, T]): (I, lent T) =
     yield (I(i), x.data[i])
     inc i
 
+func nextId*[I; T](x: Store[I, T]): I {.inline.} =
+  ## Returns the ID that would be assigned to the next added item.
+  rangeCheck x.data.len.BiggestUInt < high(I).BiggestUInt
+  result = I(x.data.len)
+
 func add*[I; T](x: var Store[I, T], it: sink T): I {.inline.} =
   ## Appends a new item to the Store and returns the ID assigned to
   ## it

From bfe73f960b8a5823d12c62f09620ac69b28c6cc5 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:15 +0000
Subject: [PATCH 2/8] jsgen: decouple `TLoc` from `TSym`

Use a `Table` to map symbols to the corresponding JavaScript name,
which removes all modifications of `TSym.loc` from `jsgen`.

Due the lesser complexity of the JavaScript code generator compared to
the C code generator, a table-based approach works well enough.
---
 compiler/backend/jsgen.nim | 177 ++++++++++++++++++++++---------------
 1 file changed, 107 insertions(+), 70 deletions(-)

diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index 6f52d529df9..bd9d01d1567 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -113,6 +113,9 @@ type
     typeInfoGenerated: IntSet
     unique: int    # for temp identifier generation
 
+    names: Table[int, string]
+      ## maps a symbol IDs to the symbol's JavaScript name
+
     extra*: seq[PSym]
 
   PProc* = ref TProc
@@ -127,6 +130,11 @@ type
     blocks: seq[TBlock]
     extraIndent: int
 
+    params: seq[string]
+      ## mangled names of the procedure's parameters
+    localNames: Table[int, string]
+      ## mapes the symbol ID of locals to the JavaScript name
+
 const
   sfModuleInit* = sfMainModule
     ## the procedure is the 'init' procedure of a module
@@ -233,7 +241,7 @@ func mangleJs(name: string): string =
     else:
       result.add("HEX" & toHex(ord(c), 2))
 
-proc mangleName(m: BModule, s: PSym): Rope =
+func mangleName(m: BModule, s: PSym): Rope =
   proc validJsName(name: string): bool =
     result = true
     const reservedWords = ["abstract", "await", "boolean", "break", "byte",
@@ -267,7 +275,37 @@ proc mangleName(m: BModule, s: PSym): Rope =
       result.add("_")
       result.add(rope(s.id))
 
-    s.loc.r = result
+proc mangledName(p: PProc, s: PSym, info: TLineInfo): lent string =
+  template get(tbl: untyped): untyped =
+    p.config.internalAssert(s.id in tbl, info):
+      "symbol has no generated name: " & s.name.s
+    tbl[s.id]
+
+  case s.kind
+  of skVar, skLet, skTemp, skForVar:
+    if sfGlobal in s.flags:
+      result = get(p.g.names)
+    else:
+      result = get(p.localNames)
+  of skResult:
+    result = get(p.localNames)
+  of skParam:
+    result = p.params[s.position]
+  of routineKinds, skConst:
+    result = get(p.g.names)
+  else:
+    unreachable()
+
+proc ensureMangledName(p: PProc, s: PSym): lent string =
+  ## Looks up and returns the mangled name for the non-local symbol
+  ## `s`, generating and caching the mangled name if it hasn't been
+  ## already.
+  let n = addr p.g.names.mgetOrPut(s.id, "")
+  if n[].len == 0:
+    # the mangled named hasn't been generated yet
+    n[] = mangleName(p.module, s)
+
+  result = n[]
 
 proc escapeJSString(s: string): string =
   result = newStringOfCap(s.len + s.len shr 2)
@@ -751,8 +789,9 @@ proc genTry(p: PProc, n: PNode) =
       # If some branch requires a local alias introduce it here. This is needed
       # since JS cannot do ``catch x as y``.
       if excAlias != nil:
-        excAlias.sym.loc.r = mangleName(p.module, excAlias.sym)
-        lineF(p, "var $1 = lastJSError;$n", excAlias.sym.loc.r)
+        let name = mangleName(p.module, excAlias.sym)
+        lineF(p, "var $1 = lastJSError;$n", name)
+        p.localNames[excAlias.sym.id] = name
       genStmt(p, n[i][^1])
       lineF(p, "}$n", [])
     inc(i)
@@ -839,7 +878,6 @@ proc genBlock(p: PProc, n: PNode) =
     # named block?
     p.config.internalAssert(n[0].kind == nkSym, n.info, "genBlock")
     var sym = n[0].sym
-    sym.loc.k = locOther
     sym.position = idx+1
   let labl = p.unique
   lineF(p, "Label$1: do {$n", [labl.rope])
@@ -856,7 +894,7 @@ proc genBreakStmt(p: PProc, n: PNode) =
     # named break?
     assert(n[0].kind == nkSym)
     let sym = n[0].sym
-    assert(sym.loc.k == locOther)
+    assert(sym.kind == skLabel)
     idx = sym.position-1
   else:
     # an unnamed 'break' can only break a loop after 'transf' pass:
@@ -910,7 +948,7 @@ proc genIf(p: PProc, n: PNode) =
   genStmt(p, it[1])
   lineF(p, "}$n", [])
 
-proc generateHeader(prc: PSym): Rope =
+proc generateHeader(prc: PSym, params: openArray[string]): Rope =
   ## Generates the JavaScript function header for `prc`. The parameters are
   ## assumed to already have their mangled names set.
   result = ""
@@ -922,7 +960,7 @@ proc generateHeader(prc: PSym): Rope =
     var param = typ.n[i].sym
     if isCompileTimeOnly(param.typ): continue
     if result != "": result.add(", ")
-    let name = param.loc.r
+    let name = params[i-1]
     result.add(name)
     if mapType(param.typ) == etyBaseIndex:
       result.add(", ")
@@ -1046,9 +1084,7 @@ proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
     r.res = makeJSString("Field" & $getFieldPosition(p, b[1]))
   else:
     p.config.internalAssert(b[1].kind == nkSym, b[1].info, "genFieldAddr")
-    var f = b[1].sym
-    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
-    r.res = makeJSString($f.loc.r)
+    r.res = makeJSString(ensureMangledName(p, b[1].sym))
   internalAssert p.config, a.typ != etyBaseIndex
   r.address = a.res
   r.kind = resExpr
@@ -1074,9 +1110,7 @@ proc genFieldAccess(p: PProc, n: PNode, r: var TCompRes) =
     mkTemp(0)
   else:
     p.config.internalAssert(n[1].kind == nkSym, n[1].info, "genFieldAccess")
-    var f = n[1].sym
-    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
-    r.res = "$1.$2" % [r.res, f.loc.r]
+    r.res = "$1.$2" % [r.res, ensureMangledName(p, n[1].sym)]
     mkTemp(1)
   r.kind = resExpr
 
@@ -1096,11 +1130,9 @@ proc genCheckedFieldOp(p: PProc, n: PNode, takeAddr: bool, r: var TCompRes) =
   # Field symbol
   var field = accessExpr[1].sym
   internalAssert p.config, field.kind == skField
-  if field.loc.r == "": field.loc.r = mangleName(p.module, field)
   # Discriminant symbol
   let disc = checkExpr[2].sym
   internalAssert p.config, disc.kind == skField
-  if disc.loc.r == "": disc.loc.r = mangleName(p.module, disc)
 
   var setx: TCompRes
   gen(p, checkExpr[1], setx)
@@ -1117,16 +1149,17 @@ proc genCheckedFieldOp(p: PProc, n: PNode, takeAddr: bool, r: var TCompRes) =
   useMagic(p, "reprDiscriminant") # no need to offset by firstOrd unlike for cgen
   let msg = genFieldDefect(p.config, field.name.s, disc)
   lineF(p, "if ($1[$2.$3]$4undefined) { raiseFieldError2(makeNimstrLit($5), reprDiscriminant($2.$3, $6)); }$n",
-    setx.res, tmp, disc.loc.r, if negCheck: ~"!==" else: ~"===",
+    setx.res, tmp, ensureMangledName(p, disc), if negCheck: ~"!==" else: ~"===",
     makeJSString(msg), genTypeInfo(p, disc.typ))
 
+  let name = ensureMangledName(p, field)
   if takeAddr:
     r.typ = etyBaseIndex
-    r.res = makeJSString($field.loc.r)
+    r.res = makeJSString(name)
     r.address = tmp
   else:
     r.typ = etyNone
-    r.res = "$1.$2" % [tmp, field.loc.r]
+    r.res = "$1.$2" % [tmp, name]
   r.kind = resExpr
 
 proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
@@ -1200,21 +1233,21 @@ proc genSymAddr(p: PProc, n: PNode, r: var TCompRes) =
   ## Generates the code for taking the address of the location identified by
   ## symbol node `n`
   let s = n.sym
-  p.config.internalAssert(s.loc.r != "", n.info, "genAddr: 3")
   case s.kind
   of skVar, skLet, skResult, skForVar, skParam:
+    let name = mangledName(p, s, n.info)
     r.kind = resExpr
     r.typ = etyBaseIndex
     r.res = "0"
     if isIndirect(s):
-      r.address = s.loc.r
+      r.address = name
     elif mapType(s.typ) == etyBaseIndex and not isBoxedPointer(s):
       # box the separate base+index into an array first
-      r.address = "[[$1, $1_Idx]]" % s.loc.r
+      r.address = "[[$1, $1_Idx]]" % name
     else:
       # something that doesn't directly support having its address
       # taken (e.g. imported variable, parameter, let, etc.)
-      r.address = "[$1]" % s.loc.r
+      r.address = "[$1]" % name
   else: internalError(p.config, n.info, $("genAddr: 2", s.kind))
 
 proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
@@ -1260,47 +1293,38 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
   else:
     internalError(p.config, n.info, "genAddr: " & $n.kind)
 
-proc genVarInit(p: PProc, v: PSym, n: PNode)
-
 proc genSym(p: PProc, n: PNode, r: var TCompRes) =
   var s = n.sym
   case s.kind
   of skVar, skLet, skParam, skTemp, skResult, skForVar:
-    p.config.internalAssert(s.loc.r != "", n.info, "symbol has no generated name: " & s.name.s)
+    let name = mangledName(p, s, n.info)
     let k = mapType(s.typ)
     if k == etyBaseIndex:
       r.typ = etyBaseIndex
       if isBoxedPointer(s):
         if isIndirect(s):
-          r.address = "$1[0][0]" % [s.loc.r]
-          r.res = "$1[0][1]" % [s.loc.r]
+          r.address = "$1[0][0]" % [name]
+          r.res = "$1[0][1]" % [name]
         else:
-          r.address = "$1[0]" % [s.loc.r]
-          r.res = "$1[1]" % [s.loc.r]
+          r.address = "$1[0]" % [name]
+          r.res = "$1[1]" % [name]
       else:
-        r.address = s.loc.r
-        r.res = s.loc.r & "_Idx"
+        r.address = name
+        r.res = name & "_Idx"
     elif isIndirect(s):
-      r.res = "$1[0]" % [s.loc.r]
+      r.res = "$1[0]" % [name]
     else:
-      r.res = s.loc.r
+      r.res = name
   of skConst:
-    p.config.internalAssert(s.loc.r != "", n.info, "symbol has no generated name: " & s.name.s)
-    r.res = s.loc.r
+    r.res = mangledName(p, s, n.info)
   of skProc, skFunc, skConverter, skMethod, skIterator:
     if sfCompileTime in s.flags:
       localReport(p.config, n.info, reportSym(
         rsemCannotCodegenCompiletimeProc, s))
 
-    discard mangleName(p.module, s)
-    r.res = s.loc.r
+    r.res = ensureMangledName(p, s)
   else:
-    p.config.internalAssert(s.loc.r != "", n.info, "symbol has no generated name: " & s.name.s)
-    if mapType(s.typ) == etyBaseIndex:
-      r.address = s.loc.r
-      r.res = s.loc.r & "_Idx"
-    else:
-      r.res = s.loc.r
+    unreachable()
   r.kind = resVal
 
 proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
@@ -1441,7 +1465,6 @@ proc genInfixCall(p: PProc, n: PNode, r: var TCompRes) =
   # don't call '$' here for efficiency:
   let f = n[0].sym
   assert sfInfixCall in f.flags
-  if f.loc.r == "": f.loc.r = mangleName(p.module, f)
   if true:
     let pat = f.loc.r
     internalAssert p.config, pat.len > 0
@@ -1610,35 +1633,37 @@ template returnType: untyped = ~""
 
 proc defineGlobal*(globals: PGlobals, m: BModule, v: PSym) =
   ## Emits the definition for the single global `v` into the top-level section,
-  ## with `m` being the module the global belongs to. Also sets up the symbols
-  ## mangled name.
+  ## with `m` being the module the global belongs to. Also sets up the
+  ## symbol's JavaScript name.
   let p = newInitProc(globals, m)
+  let name = mangleName(m, v)
   if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
-    let name = mangleName(m, v) # mutates `v`
     lineF(p, "var $1 = $2;$n", [name, createVar(p, v.typ, isIndirect(v))])
 
+  globals.names[v.id] = name
   # add to the top-level section:
   globals.code.add(p.body)
 
 proc defineGlobals*(globals: PGlobals, m: BModule, vars: openArray[PSym]) =
   ## Emits definitions for the items in `vars` into the top-level section,
-  ## with `m` being the module the globals belong to. Also updates each
-  ## symbol that requires name mangling with the mangled name.
+  ## with `m` being the module the globals belong to. Also sets up the
+  ## JavaScript name for the globals.
   let p = newInitProc(globals, m)
     ## required for emitting code
   for v in vars.items:
+    let name = mangleName(m, v)
     if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
-      let name = mangleName(m, v) # mutates `v`
       lineF(p, "var $1 = $2;$n", [name, createVar(p, v.typ, isIndirect(v))])
 
+    globals.names[v.id] = name
+
   # add to the top-level section:
   globals.code.add(p.body)
 
-proc genVarInit(p: PProc, v: PSym, n: PNode) =
+proc genVarInit(p: PProc, v: PSym, varName: string, n: PNode) =
   var
     a: TCompRes
     s: Rope
-    varName = mangleName(p.module, v)
 
   if n.kind == nkEmpty:
     if not isIndirect(v) and
@@ -1662,32 +1687,40 @@ proc genVarInit(p: PProc, v: PSym, n: PNode) =
         s = "[$1, $2]" % [a.address, a.res]
       else:
         lineF(p, "var $1 = $2, $1_Idx = $3;$n",
-                 [v.loc.r, a.address, a.res])
+                 [varName, a.address, a.res])
         # exit early because we've already emitted the definition
         return
     else:
       s = a.res
     if isIndirect(v):
-      lineF(p, "var $1 = [$2];$n", [v.loc.r, s])
+      lineF(p, "var $1 = [$2];$n", [varName, s])
     else:
-      lineF(p, "var $1 = $2;$n", [v.loc.r, s])
+      lineF(p, "var $1 = $2;$n", [varName, s])
 
 proc genVarStmt(p: PProc, n: PNode) =
   for it in n.items:
     assert it.kind == nkIdentDefs
     assert it[0].kind == nkSym
     let v = it[0].sym
+    let name = mangleName(p.module, v)
     if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
       genLineDir(p, it)
-      genVarInit(p, v, it[2])
+      genVarInit(p, v, name, it[2])
+
+    # all locals need a name:
+    p.localNames[v.id] = name
 
 proc genConstant*(g: PGlobals, m: BModule, c: PSym) =
+  let name = mangleName(m, c)
   if lfNoDecl notin c.loc.flags:
     var p = newInitProc(g, m)
     #genLineDir(p, c.ast)
-    genVarInit(p, c, c.ast)
+    genVarInit(p, c, name, c.ast)
     g.constants.add(p.body)
 
+  # all constants need a name:
+  g.names[c.id] = name
+
 proc genNew(p: PProc, n: PNode) =
   var a: TCompRes
   gen(p, n[1], a)
@@ -2085,17 +2118,17 @@ proc genObjConstr(p: PProc, n: PNode, r: var TCompRes) =
     let val = it[1]
     gen(p, val, a)
     var f = it[0].sym
-    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
+    let name = ensureMangledName(p, f)
     fieldIDs.incl(lookupFieldAgain(n.typ, f).id)
 
     let typ = val.typ.skipTypes(abstractInst)
     if a.typ == etyBaseIndex:
-      initList.addf("$#: [$#, $#]", [f.loc.r, a.address, a.res])
+      initList.addf("$#: [$#, $#]", [name, a.address, a.res])
     else:
       if not needsNoCopy(p, val):
         useMagic(p, "nimCopy")
         a.res = "nimCopy(null, $1, $2)" % [a.rdLoc, genTypeInfo(p, typ)]
-      initList.addf("$#: $#", [f.loc.r, a.res])
+      initList.addf("$#: $#", [name, a.res])
   let t = skipTypes(n.typ, abstractInst + skipPtrs)
   createObjInitList(p, t, fieldIDs, initList)
   r.res = ("{$1}") % [initList]
@@ -2219,25 +2252,29 @@ proc startProc*(g: PGlobals, module: BModule, prc: PSym): PProc =
   let p = newProc(g, module, prc, prc.options)
 
   # make sure the procedure has a mangled name:
-  discard mangleName(p.module, prc)
+  discard ensureMangledName(p, prc)
+
+  p.params.newSeq(prc.typ.len - 1 + ord(prc.typ.callConv == ccClosure))
+  # -1 for the result type
 
   # same for the result symbol and parameters:
   if prc.typ[0] != nil and sfPure notin prc.flags:
-    discard mangleName(p.module, prc.ast[resultPos].sym)
+    let s = prc.ast[resultPos].sym
+    p.localNames[s.id] = mangleName(p.module, s)
 
   # set the mangled name for the parameters:
   for i in 1..<prc.typ.n.len:
     let param = prc.typ.n[i].sym
     if not isCompileTimeOnly(param.typ):
-      discard mangleName(p.module, param)
+      p.params[i-1] = mangleName(p.module, param)
 
   if prc.typ.callConv == ccClosure:
     # generate the name for the hidden environment parameter. When creating a
     # closure object, the environment is bound to the ``this`` argument of the
     # function, hence using ``this`` for the name
-    let hidden = prc.ast[paramsPos].lastSon
-    assert hidden.kind == nkSym, "the hidden parameter is missing"
-    hidden.sym.loc.r = "this"
+    assert prc.ast[paramsPos].lastSon.kind == nkSym,
+           "the hidden parameter is missing"
+    p.params[^1] = "this"
 
   result = p
 
@@ -2251,7 +2288,7 @@ proc finishProc*(p: PProc): string =
 
   if prc.typ[0] != nil and sfPure notin prc.flags:
     let resultSym = prc.ast[resultPos].sym
-    let mname = resultSym.loc.r
+    let mname = p.localNames[resultSym.id]
     let returnAddress = not isIndirect(resultSym) and
       resultSym.typ.kind in {tyVar, tyPtr, tyLent, tyRef} and
         mapType(resultSym.typ) == etyBaseIndex
@@ -2272,8 +2309,8 @@ proc finishProc*(p: PProc): string =
     result = lineDir(p.config, prc.info, toLinenumber(prc.info))
 
   let
-    name   = prc.loc.r
-    header = generateHeader(prc)
+    name   = p.g.names[prc.id]
+    header = generateHeader(prc, p.params)
 
   var def: Rope
   if not prc.constraint.isNil:

From c4e7b46c3345cce14a1de9e3c45fba6a0a88cd45 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:16 +0000
Subject: [PATCH 3/8] ast: remove `TLoc` from `TSym` and `TType`

`TType` doesn't need a `TLoc` field at all, and `TSym` only needs to
store the external name (`extname`) plus the interface flags
(`locFlags`).

The `TLoc`, `TLocKind`, and `TStorageLoc` types are moved to `cgendata`,
with `TLocFlag` staying in the `ast` module for now.
---
 compiler/ast/ast.nim               | 20 +++++++----------
 compiler/ast/ast_types.nim         | 36 +++++++++---------------------
 compiler/backend/backends.nim      |  6 ++---
 compiler/backend/cbackend.nim      |  6 ++---
 compiler/backend/ccgexprs.nim      | 19 ++++++----------
 compiler/backend/ccgthreadvars.nim |  2 +-
 compiler/backend/ccgtypes.nim      | 14 ++++++------
 compiler/backend/cgen.nim          | 30 ++++++++++++-------------
 compiler/backend/cgendata.nim      | 28 +++++++++++++++++++++++
 compiler/backend/cgmeth.nim        |  2 +-
 compiler/backend/jsgen.nim         | 16 ++++++-------
 compiler/ic/dce.nim                |  2 +-
 compiler/ic/ic.nim                 |  8 +++----
 compiler/mir/mirbridge.nim         |  2 +-
 compiler/sem/pragmas.nim           | 28 +++++++++++------------
 compiler/sem/semtypes.nim          |  4 ++--
 compiler/sem/sighashes.nim         |  4 ++--
 compiler/vm/vmbackend.nim          |  4 ++--
 18 files changed, 118 insertions(+), 113 deletions(-)

diff --git a/compiler/ast/ast.nim b/compiler/ast/ast.nim
index 72f7215f66a..5c2f75380b1 100644
--- a/compiler/ast/ast.nim
+++ b/compiler/ast/ast.nim
@@ -309,14 +309,6 @@ proc newType*(kind: TTypeKind, id: ItemId; owner: PSym): PType =
       echo "KNID ", kind
       writeStackTrace()
 
-
-proc mergeLoc(a: var TLoc, b: TLoc) =
-  if a.k == low(typeof(a.k)): a.k = b.k
-  if a.storage == low(typeof(a.storage)): a.storage = b.storage
-  a.flags.incl b.flags
-  if a.lode == nil: a.lode = b.lode
-  if a.r.len == 0: a.r = b.r
-
 proc newSons*(father: Indexable, length: int) =
   setLen(father.sons, length)
 
@@ -333,7 +325,9 @@ proc assignType*(dest, src: PType) =
     if dest.sym != nil:
       dest.sym.flags.incl src.sym.flags-{sfExported}
       if dest.sym.annex == nil: dest.sym.annex = src.sym.annex
-      mergeLoc(dest.sym.loc, src.sym.loc)
+      dest.sym.locFlags.incl src.sym.locFlags
+      if dest.sym.extname.len == 0:
+        dest.sym.extname = src.sym.extname
     else:
       dest.sym = src.sym
   newSons(dest, src.len)
@@ -355,7 +349,8 @@ proc copySym*(s: PSym; id: ItemId): PSym =
   result.magic = s.magic
   result.options = s.options
   result.position = s.position
-  result.loc = s.loc
+  result.extname = s.extname
+  result.locFlags = s.locFlags
   result.annex = s.annex      # BUGFIX
   result.constraint = s.constraint
   if result.kind in {skVar, skLet, skField}:
@@ -372,7 +367,8 @@ proc createModuleAlias*(s: PSym, id: ItemId, newIdent: PIdent, info: TLineInfo;
   result.flags = s.flags
   result.options = s.options
   result.position = s.position
-  result.loc = s.loc
+  result.extname = s.extname
+  result.locFlags = s.locFlags
   result.annex = s.annex
 
 proc initStrTable*(x: var TStrTable) =
@@ -510,7 +506,7 @@ template transitionSymKindCommon*(k: TSymKind) =
   s[] = TSym(kind: k, itemId: obj.itemId, magic: obj.magic, typ: obj.typ, name: obj.name,
              info: obj.info, owner: obj.owner, flags: obj.flags, ast: obj.ast,
              options: obj.options, position: obj.position, offset: obj.offset,
-             loc: obj.loc, locId: obj.locId,
+             extname: obj.extname, locFlags: obj.locFlags, locId: obj.locId,
              annex: obj.annex, constraint: obj.constraint)
   when defined(nimsuggest):
     s.allUsages = obj.allUsages
diff --git a/compiler/ast/ast_types.nim b/compiler/ast/ast_types.nim
index d7136e464bb..f37e2080ad0 100644
--- a/compiler/ast/ast_types.nim
+++ b/compiler/ast/ast_types.nim
@@ -1590,19 +1590,13 @@ type
     data*: seq[PSym]
 
   # -------------- backend information -------------------------------
-  TLocKind* = enum
-    locNone,                  ## no location
-    locTemp,                  ## temporary location
-    locLocalVar,              ## location is a local variable
-    locGlobalVar,             ## location is a global variable
-    locParam,                 ## location is a parameter
-    locField,                 ## location is a record field
-    locExpr,                  ## "location" is really an expression
-    locProc,                  ## location is a proc (an address of a procedure)
-    locData,                  ## location is a constant
-    locCall,                  ## location is a call expression
-    locOther                  ## location is something other
   TLocFlag* = enum
+    # XXX: `TLocFlag` conflates two things:
+    #      - flags regarding the external interface (e.g., `lfHeader`; set by
+    #        sem, used by sem and the code generators)
+    #      - location-related flags (e.g., ``lfIndirect``, ``lfSingleUse``,
+    #        etc.; only relevant to the C code generator)
+    #      Split the enum up.
     lfIndirect,               ## backend introduced a pointer
     lfFullExternalName, ## only used when 'conf.cmd == cmdNimfix': Indicates
       ## that the symbol has been imported via 'importc: "fullname"' and
@@ -1617,19 +1611,8 @@ type
                               ## ptr array due to C array limitations.
                               ## See #1181, #6422, #11171
     lfPrepareForMutation      ## string location is about to be mutated (V2)
-  TStorageLoc* = enum
-    OnUnknown,                ## location is unknown (stack, heap or static)
-    OnStatic,                 ## in a static section
-    OnStack,                  ## location is on hardware stack
-    OnHeap                    ## location is on heap or global
-                              ## (reference counting needed)
+
   TLocFlags* = set[TLocFlag]
-  TLoc* = object
-    k*: TLocKind              ## kind of location
-    storage*: TStorageLoc
-    flags*: TLocFlags         ## location's flags
-    lode*: PNode              ## Node where the location came from; can be faked
-    r*: Rope                  ## rope value of location (code generators)
 
   # ---------------- end of backend information ------------------------------
 
@@ -1713,7 +1696,10 @@ type
                               ## to the module's fileIdx
                               ## for variables a slot index for the evaluator
     offset*: int              ## offset of record field
-    loc*: TLoc
+    extname*: string          ## the external name of the type, or empty if a
+                              ## generated name is to be used
+    locFlags*: TLocFlags      ## additional flags that are relevant to code
+                              ## generation
     locId*: uint32            ## associates the symbol with a loc in the C code
                               ## generator. 0 means unset.
     annex*: PLib              ## additional fields (seldom used, so we use a
diff --git a/compiler/backend/backends.nim b/compiler/backend/backends.nim
index c55004535ac..5a85e996af6 100644
--- a/compiler/backend/backends.nim
+++ b/compiler/backend/backends.nim
@@ -486,7 +486,7 @@ func discoverFrom*(data: var DiscoveryData, decl: PNode) =
     of nkProcDef, nkFuncDef, nkConverterDef, nkMethodDef:
       let prc = n[namePos].sym
       if {sfExportc, sfCompilerProc} * prc.flags == {sfExportc} or
-         (sfExportc in prc.flags and lfExportLib in prc.loc.flags):
+         (sfExportc in prc.flags and lfExportLib in prc.locFlags):
         # an exported routine. It must always have code generated for it. Note
         # that compilerprocs, while exported, are still only have code generated
         # for them when used
@@ -524,7 +524,7 @@ func queue(iter: var ProcedureIter, prc: PSym, m: FileIndex) =
   ## If eligible for processing and code generation, adds `prc` to
   ## `iter`'s queue.
   assert prc.kind in routineKinds
-  if lfNoDecl notin prc.loc.flags and
+  if lfNoDecl notin prc.locFlags and
      (sfImportc notin prc.flags or (iter.config.noImported and
                                     prc.ast[bodyPos].kind != nkEmpty)):
     iter.queued.add (prc, m)
@@ -564,7 +564,7 @@ proc preprocessDynlib(graph: ModuleGraph, idgen: IdGenerator,
   #       horrendous, but fortunately, this hack (`preprocessDynlib``) can
   #       be removed once handling of dynlib procedures and globals is fully
   #       implemented in the ``process`` iterator
-  if lfDynamicLib in sym.loc.flags:
+  if lfDynamicLib in sym.locFlags:
     if sym.annex.path.kind in nkStrKinds:
       # it's a string, no need to transform nor scan it
       discard
diff --git a/compiler/backend/cbackend.nim b/compiler/backend/cbackend.nim
index fa7b74d4fbd..8c931c9aa21 100644
--- a/compiler/backend/cbackend.nim
+++ b/compiler/backend/cbackend.nim
@@ -151,7 +151,7 @@ proc processEvent(g: BModuleList, inl: var InliningData, discovery: var Discover
   # XXX: dynlib procedure handling is going to move into the unified backend
   #      processing pipeline (i.e., the ``process`` iterator) in the future
   for _, s in peek(discovery.procedures):
-    if lfDynamicLib in s.loc.flags:
+    if lfDynamicLib in s.locFlags:
       let m = g.modules[s.itemId.module.int]
       fillProcLoc(m, newSymNode(s))
       symInDynamicLib(m, s)
@@ -365,8 +365,8 @@ proc generateCode*(graph: ModuleGraph, g: BModuleList, mlist: sink ModuleList) =
 
     # the init and data-init procedures use special names in the
     # generated code:
-    m.init.loc.r = getInitName(bmod)
-    m.dataInit.loc.r = getDatInitName(bmod)
+    m.init.extname = getInitName(bmod)
+    m.dataInit.extname = getDatInitName(bmod)
 
     # mark the init procedure so that the code generator can detect and
     # special-case it:
diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index 426972274c3..cefd14d5783 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -1901,12 +1901,11 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
     # Why would anyone want to set nodecl to one of these hardcoded magics?
     # - not sure, and it wouldn't work if the symbol behind the magic isn't
     #   somehow forward-declared from some other usage, but it is *possible*
-    if lfNoDecl notin opr.loc.flags:
-      let prc = magicsys.getCompilerProc(p.module.g.graph, $opr.loc.r)
-      assert prc != nil, $opr.loc.r
-      # Make the function behind the magic get actually generated - this will
-      # not lead to a forward declaration! The genCall will lead to one.
-      discard cgsym(p.module, $opr.loc.r)
+    if lfNoDecl notin opr.locFlags:
+      let prc = magicsys.getCompilerProc(p.module.g.graph, opr.extname)
+      assert prc != nil, opr.extname
+      # Make the function behind the magic get actually generated
+      discard cgsym(p.module, opr.extname)
 
     genCall(p, e, d)
   of mDefault: genDefault(p, e, d)
@@ -2125,13 +2124,9 @@ proc exprComplexConst(p: BProc, n: PNode, d: var TLoc) =
     if t.kind notin {tySequence, tyString}:
       d.storage = OnStatic
 
-proc fillConstLoc(m: BModule, sym: PSym) =
-  if sym.loc.k == locNone:
-    fillLoc(sym.loc, locData, sym.ast, mangleName(m, sym), OnStatic)
-
 proc useConst*(m: BModule; sym: PSym) =
   useHeader(m, sym)
-  if lfNoDecl in sym.loc.flags:
+  if lfNoDecl in sym.locFlags:
     return
 
   let q = findPendingModule(m, sym)
@@ -2144,7 +2139,7 @@ proc useConst*(m: BModule; sym: PSym) =
 
 proc genConstDefinition*(q: BModule; sym: PSym) =
   let name = mangleName(q, sym)
-  if lfNoDecl notin sym.loc.flags:
+  if lfNoDecl notin sym.locFlags:
     let p = newProc(nil, q)
     q.s[cfsData].addf("N_LIB_PRIVATE NIM_CONST $1 $2 = $3;$n",
         [getTypeDesc(q, sym.typ), name,
diff --git a/compiler/backend/ccgthreadvars.nim b/compiler/backend/ccgthreadvars.nim
index 704eeaa4650..e3b8591f021 100644
--- a/compiler/backend/ccgthreadvars.nim
+++ b/compiler/backend/ccgthreadvars.nim
@@ -33,7 +33,7 @@ proc declareThreadVar*(m: BModule, s: PSym, isExtern: bool) =
       m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.typ), m.globals[s].r])
   else:
     if isExtern: m.s[cfsVars].add("extern ")
-    elif lfExportLib in s.loc.flags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
+    elif lfExportLib in s.locFlags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
     else: m.s[cfsVars].add("N_LIB_PRIVATE ")
     if optThreads in m.config.globalOptions:
       m.s[cfsVars].add("NIM_THREADVAR ")
diff --git a/compiler/backend/ccgtypes.nim b/compiler/backend/ccgtypes.nim
index 5d2109e0701..3c56c67d9ff 100644
--- a/compiler/backend/ccgtypes.nim
+++ b/compiler/backend/ccgtypes.nim
@@ -34,7 +34,7 @@ proc mangleField(m: BModule; name: PIdent): string =
     result.add "_0"
 
 proc mangleName(m: BModule; s: PSym): Rope =
-  result = s.loc.r
+  result = s.extname
   if result == "":
     result = s.name.s.mangle.rope
     result.add "__"
@@ -46,7 +46,7 @@ proc mangleParamName(m: BModule; s: PSym): Rope =
   ## we cannot use 'sigConflicts' here since we have a BModule, not a BProc.
   ## Fortunately C's scoping rules are sane enough so that that doesn't
   ## cause any trouble.
-  result = s.loc.r
+  result = s.extname
   if result == "":
     var res = s.name.s.mangle
     if isKeyword(s.name) or m.g.config.cppDefines.contains(res):
@@ -57,7 +57,7 @@ proc mangleParamName(m: BModule; s: PSym): Rope =
 proc mangleLocalName(p: BProc; s: PSym): Rope =
   assert s.kind in skLocalVars+{skTemp}
   #assert sfGlobal notin s.flags
-  result = s.loc.r
+  result = s.extname
   if result == "":
     var key: string
     shallowCopy(key, s.name.s.mangle)
@@ -95,7 +95,7 @@ proc getTypeName(m: BModule; typ: PType; sig: SigHash): Rope =
   var t = typ
   while true:
     if t.sym != nil and {sfImportc, sfExportc} * t.sym.flags != {}:
-      return t.sym.loc.r
+      return t.sym.extname
 
     if t.kind in irrelevantForBackend:
       t = t.lastSon
@@ -224,7 +224,7 @@ proc initResultParamLoc(conf: ConfigRef; param: PNode): TLoc =
 proc typeNameOrLiteral(m: BModule; t: PType, literal: string): Rope =
   if t.sym != nil and sfImportc in t.sym.flags and t.sym.magic == mNone:
     useHeader(m, t.sym)
-    result = t.sym.loc.r
+    result = t.sym.extname
   else:
     result = rope(literal)
 
@@ -442,7 +442,7 @@ proc genProcParams(m: BModule, t: PType, rettype, params: var Rope,
 
 proc mangleRecFieldName(m: BModule; field: PSym): Rope =
   if {sfImportc, sfExportc} * field.flags != {}:
-    result = field.loc.r
+    result = field.extname
   else:
     result = rope(mangleField(m, field.name))
   m.config.internalAssert(result != "", field.info, "mangleRecFieldName")
@@ -795,7 +795,7 @@ proc genProcHeader(m: BModule, prc: PSym, locs: openArray[TLoc]): Rope =
   var
     rettype, params: Rope
   # using static is needed for inline procs
-  if lfExportLib in prc.loc.flags:
+  if lfExportLib in prc.locFlags:
     if isHeaderFile in m.flags:
       result.add "N_LIB_IMPORT "
     else:
diff --git a/compiler/backend/cgen.nim b/compiler/backend/cgen.nim
index bf8f4f0802c..c7c00c78e44 100644
--- a/compiler/backend/cgen.nim
+++ b/compiler/backend/cgen.nim
@@ -144,7 +144,7 @@ proc isSimpleConst(typ: PType): bool =
       (t.kind == tyProc and t.callConv == ccClosure)
 
 proc useHeader(m: BModule, sym: PSym) =
-  if lfHeader in sym.loc.flags:
+  if lfHeader in sym.locFlags:
     assert(sym.annex != nil)
     let str = getStr(sym.annex.path)
     m.includeHeader(str)
@@ -541,12 +541,12 @@ proc defineGlobalVar*(m: BModule, n: PNode) =
   assert s.id notin m.declaredThings
   assert findPendingModule(m, s) == m, "not the attached-to module"
 
-  if lfDynamicLib in s.loc.flags:
+  if lfDynamicLib in s.locFlags:
     incl(m.declaredThings, s.id)
     varInDynamicLib(m, s)
   else:
     useHeader(m, s)
-    if lfNoDecl notin s.loc.flags:
+    if lfNoDecl notin s.locFlags:
       incl(m.declaredThings, s.id)
       var decl = ""
       var td = getTypeDesc(m, m.globals[s].t, skVar)
@@ -554,7 +554,7 @@ proc defineGlobalVar*(m: BModule, n: PNode) =
         if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
           decl.addf "NIM_ALIGN($1) ", [rope(s.alignment)]
         if sfImportc in s.flags: decl.add("extern ")
-        elif lfExportLib in s.loc.flags: decl.add("N_LIB_EXPORT_VAR ")
+        elif lfExportLib in s.locFlags: decl.add("N_LIB_EXPORT_VAR ")
         else: decl.add("N_LIB_PRIVATE ")
         decl.add(td)
         if sfRegister in s.flags: decl.add(" register")
@@ -682,7 +682,7 @@ proc loadDynamicLib(m: BModule, lib: PLib) =
 
 proc mangleDynLibProc(sym: PSym): Rope =
   if sfCompilerProc in sym.flags:
-    # NOTE: sym.loc.r is the external name!
+    # NOTE: sym.extname is the external name!
     result = rope(sym.name.s)
   else:
     result = rope(strutils.`%`("Dl_$1_", $sym.id))
@@ -690,7 +690,7 @@ proc mangleDynLibProc(sym: PSym): Rope =
 proc symInDynamicLib*(m: BModule, sym: PSym) =
   var lib = sym.annex
   let isCall = isGetProcAddr(lib)
-  var extname = sym.loc.r
+  let extname = sym.extname
   if not isCall: loadDynamicLib(m, lib)
   let tmp = mangleDynLibProc(sym)
   # XXX: dynlib procedures should be treated as globals here (because that's
@@ -728,7 +728,7 @@ proc symInDynamicLib*(m: BModule, sym: PSym) =
 
 proc varInDynamicLib(m: BModule, sym: PSym) =
   var lib = sym.annex
-  var extname = sym.loc.r
+  let extname = sym.extname
   loadDynamicLib(m, lib)
   let tmp = mangleDynLibProc(sym)
   incl(m.globals[sym].flags, lfIndirect)
@@ -756,7 +756,7 @@ proc cgsym(m: BModule, name: string): Rope =
     # we're picky here for the system module too:
     localReport(m.config, reportStr(rsemSystemNeeds, name))
 
-  result = sym.loc.r
+  result = sym.extname
 
 proc generateHeaders(m: BModule) =
   m.s[cfsHeaders].add("\L#include \"nimbase.h\"\L")
@@ -949,7 +949,7 @@ proc startProc*(m: BModule, prc: PSym; procBody: PNode = nil): BProc =
       else:
         resetLoc(p, p.params[0])
       if skipTypes(res.typ, abstractInst).kind == tyArray:
-        #incl(res.loc.flags, lfIndirect)
+        #incl(res.locFlags, lfIndirect)
         p.params[0].storage = OnUnknown
 
   # for now, we treat all compilerprocs as being able to run in a boot
@@ -1039,8 +1039,8 @@ proc genProc*(m: BModule, prc: PSym, procBody: PNode): Rope =
 
 proc genProcPrototype(m: BModule, sym: PSym) =
   useHeader(m, sym)
-  if lfNoDecl in sym.loc.flags: return
-  if lfDynamicLib in sym.loc.flags:
+  if lfNoDecl in sym.locFlags: return
+  if lfDynamicLib in sym.locFlags:
     if sym.itemId.module != m.module.position and
         not containsOrIncl(m.declaredThings, sym.id):
       m.s[cfsVars].add(ropecg(m, "$1 $2 $3;$n",
@@ -1061,12 +1061,12 @@ proc genProcPrototype(m: BModule, sym: PSym) =
     m.s[cfsProcHeaders].add(ropecg(m, "$1;$N", [header]))
 
 proc useProc(m: BModule, prc: PSym) =
-  if lfImportCompilerProc in prc.loc.flags:
+  if lfImportCompilerProc in prc.locFlags:
     fillProcLoc(m, prc.ast[namePos])
     useHeader(m, prc)
     # dependency to a compilerproc:
     discard cgsym(m, prc.name.s)
-  elif lfNoDecl in prc.loc.flags or sfImportc in prc.flags:
+  elif lfNoDecl in prc.locFlags or sfImportc in prc.flags:
     fillProcLoc(m, prc.ast[namePos])
     genProcPrototype(m, prc)
   else:
@@ -1078,7 +1078,7 @@ proc genVarPrototype(m: BModule, n: PNode) =
   #assert(sfGlobal in sym.flags)
   let sym = n.sym
   useHeader(m, sym)
-  if (lfNoDecl in sym.loc.flags) or contains(m.declaredThings, sym.id):
+  if (lfNoDecl in sym.locFlags) or contains(m.declaredThings, sym.id):
     return
   if sym.owner.id != m.module.id:
     # else we already have the symbol generated!
@@ -1090,7 +1090,7 @@ proc genVarPrototype(m: BModule, n: PNode) =
         m.s[cfsVars].addf "NIM_ALIGN($1) ", [rope(sym.alignment)]
       m.s[cfsVars].add("extern ")
       m.s[cfsVars].add(getTypeDesc(m, sym.typ, skVar))
-      if lfDynamicLib in sym.loc.flags: m.s[cfsVars].add("*")
+      if lfDynamicLib in sym.locFlags: m.s[cfsVars].add("*")
       if sfRegister in sym.flags: m.s[cfsVars].add(" register")
       if sfVolatile in sym.flags: m.s[cfsVars].add(" volatile")
       if sfNoalias in sym.flags: m.s[cfsVars].add(" NIM_NOALIAS")
diff --git a/compiler/backend/cgendata.nim b/compiler/backend/cgendata.nim
index 3895ad2fbf6..f3848f7d4ab 100644
--- a/compiler/backend/cgendata.nim
+++ b/compiler/backend/cgendata.nim
@@ -45,6 +45,34 @@ type
     ## ``TSym.locId``.
     store: Store[range[0'u32..high(uint32)-1], T]
 
+  TLocKind* = enum
+    locNone,                  ## no location
+    locTemp,                  ## temporary location
+    locLocalVar,              ## location is a local variable
+    locGlobalVar,             ## location is a global variable
+    locParam,                 ## location is a parameter
+    locField,                 ## location is a record field
+    locExpr,                  ## "location" is really an expression
+    locProc,                  ## location is a proc (an address of a procedure)
+    locData,                  ## location is a constant
+    locCall,                  ## location is a call expression
+    locOther                  ## location is something other
+
+  TStorageLoc* = enum
+    # XXX: ``TStorageLoc`` is obsolete -- remove it
+    OnUnknown,                ## location is unknown (stack, heap or static)
+    OnStatic,                 ## in a static section
+    OnStack,                  ## location is on hardware stack
+    OnHeap                    ## location is on heap or global
+                              ## (reference counting needed)
+
+  TLoc* = object
+    k*: TLocKind              ## kind of location
+    storage*: TStorageLoc
+    flags*: TLocFlags         ## location's flags
+    lode*: PNode              ## Node where the location came from; can be faked
+    r*: Rope                  ## rope value of location (code generators)
+
   TLabel* = Rope              ## for the C generator a label is just a rope
   TCFileSection* = enum       ## the sections a generated C file consists of
     cfsMergeInfo,             ## section containing merge information
diff --git a/compiler/backend/cgmeth.nim b/compiler/backend/cgmeth.nim
index 130f84079be..631cee55e35 100644
--- a/compiler/backend/cgmeth.nim
+++ b/compiler/backend/cgmeth.nim
@@ -148,7 +148,7 @@ proc createDispatcher(s: PSym; g: ModuleGraph; idgen: IdGenerator): PSym =
   if disp.typ.callConv == ccInline: disp.typ.callConv = ccNimCall
   disp.ast = copyTree(s.ast)
   disp.ast[bodyPos] = newNodeI(nkEmpty, s.info)
-  disp.loc.r = ""
+  disp.extname = ""
   if s.typ[0] != nil:
     if disp.ast.len > resultPos:
       disp.ast[resultPos].sym = copySym(s.ast[resultPos].sym, nextSymId(idgen))
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index bd9d01d1567..b23baa03663 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -262,7 +262,7 @@ func mangleName(m: BModule, s: PSym): Rope =
     for chr in name:
       if chr notin {'A'..'Z','a'..'z','_','$','0'..'9'}:
         return false
-  result = s.loc.r
+  result = s.extname
   if result == "":
     if s.kind == skField and s.name.s.validJsName:
       result = rope(s.name.s)
@@ -779,7 +779,7 @@ proc genTry(p: PProc, n: PNode) =
         # if isJsObject(throwObj.typ):
         if isImportedException(throwObj.typ, p.config):
           orExpr.addf("lastJSError instanceof $1",
-            [throwObj.typ.sym.loc.r])
+            [throwObj.typ.sym.extname])
         else:
           orExpr.addf("isObj(lastJSError.m_type, $1)",
                [genTypeInfo(p, throwObj.typ)])
@@ -1466,7 +1466,7 @@ proc genInfixCall(p: PProc, n: PNode, r: var TCompRes) =
   let f = n[0].sym
   assert sfInfixCall in f.flags
   if true:
-    let pat = f.loc.r
+    let pat = f.extname
     internalAssert p.config, pat.len > 0
     if pat.contains({'#', '(', '@'}):
       var typ = skipTypes(n[0].typ, abstractInst)
@@ -1562,7 +1562,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
   var t = skipTypes(typ, abstractInst)
   case t.kind
   of tyInt..tyInt64, tyUInt..tyUInt64, tyEnum, tyChar:
-    if $t.sym.loc.r == "bigint":
+    if t.sym.extname == "bigint":
       result = putToSeq("0n", indirect)
     else:
       result = putToSeq("0", indirect)
@@ -1637,7 +1637,7 @@ proc defineGlobal*(globals: PGlobals, m: BModule, v: PSym) =
   ## symbol's JavaScript name.
   let p = newInitProc(globals, m)
   let name = mangleName(m, v)
-  if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
+  if lfNoDecl notin v.locFlags and sfImportc notin v.flags:
     lineF(p, "var $1 = $2;$n", [name, createVar(p, v.typ, isIndirect(v))])
 
   globals.names[v.id] = name
@@ -1652,7 +1652,7 @@ proc defineGlobals*(globals: PGlobals, m: BModule, vars: openArray[PSym]) =
     ## required for emitting code
   for v in vars.items:
     let name = mangleName(m, v)
-    if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
+    if lfNoDecl notin v.locFlags and sfImportc notin v.flags:
       lineF(p, "var $1 = $2;$n", [name, createVar(p, v.typ, isIndirect(v))])
 
     globals.names[v.id] = name
@@ -1703,7 +1703,7 @@ proc genVarStmt(p: PProc, n: PNode) =
     assert it[0].kind == nkSym
     let v = it[0].sym
     let name = mangleName(p.module, v)
-    if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
+    if lfNoDecl notin v.locFlags and sfImportc notin v.flags:
       genLineDir(p, it)
       genVarInit(p, v, name, it[2])
 
@@ -1712,7 +1712,7 @@ proc genVarStmt(p: PProc, n: PNode) =
 
 proc genConstant*(g: PGlobals, m: BModule, c: PSym) =
   let name = mangleName(m, c)
-  if lfNoDecl notin c.loc.flags:
+  if lfNoDecl notin c.locFlags:
     var p = newInitProc(g, m)
     #genLineDir(p, c.ast)
     genVarInit(p, c, name, c.ast)
diff --git a/compiler/ic/dce.nim b/compiler/ic/dce.nim
index 88cbe13ffe7..6a1c92dc759 100644
--- a/compiler/ic/dce.nim
+++ b/compiler/ic/dce.nim
@@ -63,7 +63,7 @@ proc isExportedToC(c: var AliveContext; g: PackedModuleGraph; symId: int32): boo
         (symPtr.kind == skMethod):
       result = true
       # XXX: This used to be a condition to:
-      #  (sfExportc in prc.flags and lfExportLib in prc.loc.flags) or
+      #  (sfExportc in prc.flags and lfExportLib in prc.locFlags) or
     if sfCompilerProc in flags:
       c.compilerProcs[g[c.thisModule].fromDisk.strings[symPtr.name]] = (c.thisModule, symId)
 
diff --git a/compiler/ic/ic.nim b/compiler/ic/ic.nim
index b30c68baa82..724a71e87d3 100644
--- a/compiler/ic/ic.nim
+++ b/compiler/ic/ic.nim
@@ -418,8 +418,8 @@ proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
       p.bitsize = s.bitsize
       p.alignment = s.alignment
 
-    p.externalName = toLitId(s.loc.r, m)
-    p.locFlags = s.loc.flags
+    p.externalName = toLitId(s.extname, m)
+    p.locFlags = s.locFlags
     c.addMissing s.typ
     p.typ = s.typ.storeType(c, m)
     c.addMissing s.owner
@@ -878,8 +878,8 @@ proc symBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
   result.owner = loadSym(c, g, si, s.owner)
   let externalName = g[si].fromDisk.strings[s.externalName]
   if externalName != "":
-    result.loc.r = rope externalName
-  result.loc.flags = s.locFlags
+    result.extname = rope externalName
+  result.locFlags = s.locFlags
 
 proc loadSym(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; s: PackedItemId): PSym =
   if s == nilItemId:
diff --git a/compiler/mir/mirbridge.nim b/compiler/mir/mirbridge.nim
index 40445c8647c..70c06bb94cf 100644
--- a/compiler/mir/mirbridge.nim
+++ b/compiler/mir/mirbridge.nim
@@ -125,7 +125,7 @@ proc rewriteGlobalDefs*(body: var MirTree, sourceMap: var SourceMap,
               buf.add MirNode(kind: mnkConsume, typ: typ)
             buf.add MirNode(kind: mnkInit)
         elif {sfImportc, sfNoInit} * sym.flags == {} and
-             {lfDynamicLib, lfNoDecl} * sym.loc.flags == {}:
+             {lfDynamicLib, lfNoDecl} * sym.locFlags == {}:
           # XXX: ^^ re-think this condition from first principles. Right now,
           #      it's just meant to make some tests work
           # the location doesn't have an explicit starting value. Initialize
diff --git a/compiler/sem/pragmas.nim b/compiler/sem/pragmas.nim
index ec21e42266d..f5aa1b62e09 100644
--- a/compiler/sem/pragmas.nim
+++ b/compiler/sem/pragmas.nim
@@ -205,14 +205,14 @@ proc setExternName(c: PContext; s: PSym, ext: string) =
 
   # special cases to improve performance:
   if ext == "$1":
-    s.loc.r = s.name.s
+    s.extname = s.name.s
   elif '$' notin ext:
-    s.loc.r = ext
+    s.extname = ext
   else:
-    s.loc.r = ext % s.name.s
+    s.extname = ext % s.name.s
   if c.config.cmd == cmdNimfix and '$' notin ext:
     # note that '{.importc.}' is transformed into '{.importc: "$1".}'
-    s.loc.flags.incl(lfFullExternalName)
+    s.locFlags.incl(lfFullExternalName)
 
 proc makeExternImport(c: PContext; s: PSym, ext: string) =
   ## produces (mutates) `s`'s `loc`ation setting the import name, marks it as
@@ -235,7 +235,7 @@ proc processImportCompilerProc(c: PContext; s: PSym, ext: string) =
   setExternName(c, s, ext)
   incl(s.flags, sfImportc)
   excl(s.flags, sfForward)
-  incl(s.loc.flags, lfImportCompilerProc)
+  incl(s.locFlags, lfImportCompilerProc)
 
 proc getStrLitNode(c: PContext, n: PNode): PNode =
   ## returns a PNode that's either an error or a string literal node
@@ -402,9 +402,9 @@ proc processDynLib(c: PContext, n: PNode, sym: PSym): PNode =
         var lib = getLib(c, libDynamic, libNode)
         if not lib.isOverriden:
           addToLib(lib, sym)
-          incl(sym.loc.flags, lfDynamicLib)
+          incl(sym.locFlags, lfDynamicLib)
     else:
-      incl(sym.loc.flags, lfExportLib)
+      incl(sym.locFlags, lfExportLib)
     # since we'll be loading the dynlib symbols dynamically, we must use
     # a calling convention that doesn't introduce custom name mangling
     # cdecl is the default - the user can override this explicitly
@@ -1150,7 +1150,7 @@ proc applySymbolPragma(c: PContext, sym: PSym, it: PNode): PNode =
             c.config.newError(it, PAstDiag(kind: adSemAlignRequiresPowerOfTwo))
       of wNodecl:
         result = noVal(c, it)
-        incl(sym.loc.flags, lfNoDecl)
+        incl(sym.locFlags, lfNoDecl)
       of wPure, wAsmNoStackFrame:
         result = noVal(c, it)
         incl(sym.flags, sfPure)
@@ -1192,9 +1192,9 @@ proc applySymbolPragma(c: PContext, sym: PSym, it: PNode): PNode =
         let lib = getLib(c, libHeader, path)
         addToLib(lib, sym)
         sym.flags.incl sfImportc
-        sym.loc.flags.incl {lfHeader, lfNoDecl}
+        sym.locFlags.incl {lfHeader, lfNoDecl}
         # implies nodecl, because otherwise header would not make sense
-        if sym.loc.r == "": sym.loc.r = sym.name.s
+        if sym.extname == "": sym.extname = sym.name.s
       of wNoSideEffect:
         result = noVal(c, it)
         incl(sym.flags, sfNoSideEffect)
@@ -1853,13 +1853,13 @@ proc inheritDynlib*(c: PContext, sym: PSym) =
   ## imported, but no header nor dynlib are specified.
   let lib = c.optionStack[^1].dynlib
   if lib != nil and sfImportc in sym.flags and
-     {lfDynamicLib, lfHeader} * sym.loc.flags == {}:
-    incl(sym.loc.flags, lfDynamicLib)
+     {lfDynamicLib, lfHeader} * sym.locFlags == {}:
+    incl(sym.locFlags, lfDynamicLib)
     addToLib(lib, sym)
-    if sym.loc.r == "":
+    if sym.extname == "":
       # XXX: this looks like a unnecessary defensive check. If the symbol is
       #      marked as imported, it already has an external name set
-      sym.loc.r = sym.name.s
+      sym.extname = sym.name.s
 
 proc containsError(n: PNode): bool =
   for it in n.items:
diff --git a/compiler/sem/semtypes.nim b/compiler/sem/semtypes.nim
index 0ebc2dffe8a..108314efe51 100644
--- a/compiler/sem/semtypes.nim
+++ b/compiler/sem/semtypes.nim
@@ -930,8 +930,8 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
       f.options = c.config.options
       if fieldOwner != nil and
          {sfImportc, sfExportc} * fieldOwner.flags != {} and
-         not hasCaseFields and f.loc.r == "":
-        f.loc.r = rope(f.name.s)
+         not hasCaseFields and f.extname == "":
+        f.extname = rope(f.name.s)
         f.flags.incl {sfImportc, sfExportc} * fieldOwner.flags
       inc(pos)
       if containsOrIncl(check, f.name.id):
diff --git a/compiler/sem/sighashes.nim b/compiler/sem/sighashes.nim
index 3e05475a0a3..39043605beb 100644
--- a/compiler/sem/sighashes.nim
+++ b/compiler/sem/sighashes.nim
@@ -152,9 +152,9 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]) =
     # is actually safe without an infinite recursion check:
     if t.sym != nil:
       if {sfCompilerProc} * t.sym.flags != {}:
-        doAssert t.sym.loc.r != ""
+        doAssert t.sym.extname != ""
         # The user has set a specific name for this type
-        c &= t.sym.loc.r
+        c &= t.sym.extname
       elif CoOwnerSig in flags:
         c.hashTypeSym(t.sym)
       else:
diff --git a/compiler/vm/vmbackend.nim b/compiler/vm/vmbackend.nim
index 54a76102176..e015f8b8e8c 100644
--- a/compiler/vm/vmbackend.nim
+++ b/compiler/vm/vmbackend.nim
@@ -132,7 +132,7 @@ proc genStmt(c: var TCtx, f: var CodeFragment, stmt: PNode) =
 proc declareGlobal(c: var TCtx, sym: PSym) =
   # we silently ignore imported globals here and let ``vmgen`` raise an
   # error when one is accessed
-  if lfNoDecl notin sym.loc.flags and sfImportc notin sym.flags:
+  if lfNoDecl notin sym.locFlags and sfImportc notin sym.flags:
     # make sure the type is generated and register the global in the
     # link table
     discard getOrCreate(c, sym.typ)
@@ -153,7 +153,7 @@ proc prepare(c: var TCtx, data: var DiscoveryData) =
     # don't want any processing to happen for it, which we signal to the
     # event producer via ``lfNoDecl``
     if c.functions[i].kind == ckCallback:
-      it.loc.flags.incl lfNoDecl
+      it.locFlags.incl lfNoDecl
 
   # register the constants with the link table:
   for i, s in visit(data.constants):

From 397e5af71bdec08a43075c90435f4f8079a3ff3a Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:16 +0000
Subject: [PATCH 4/8] cbackend: restore NDI generation

The orchestrator is now responsible for writing the mangled names to the
NDI files.
---
 compiler/ast/ndi.nim          | 14 ++++++------
 compiler/backend/cbackend.nim | 42 +++++++++++++++++++++++++++++++++--
 2 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/compiler/ast/ndi.nim b/compiler/ast/ndi.nim
index e8a6e1bb1bc..b88a27dbd73 100644
--- a/compiler/ast/ndi.nim
+++ b/compiler/ast/ndi.nim
@@ -29,19 +29,19 @@ type
     f: File
     buf: string
     filename: AbsoluteFile
-    syms: seq[PSym]
+    syms: seq[tuple[s: PSym, name: string]]
 
-proc doWrite(f: var NdiFile; s: PSym; conf: ConfigRef) =
+proc doWrite(f: var NdiFile; s: PSym; name: string, conf: ConfigRef) =
   f.buf.setLen 0
   f.buf.addInt s.info.line.int
   f.buf.add "\t"
   f.buf.addInt s.info.col.int
   f.f.write(s.name.s, "\t")
-  f.f.writeRope(s.loc.r)
+  f.f.writeRope(name)
   f.f.writeLine("\t", toFullPath(conf, s.info), "\t", f.buf)
 
-template writeMangledName*(f: NdiFile; s: PSym; conf: ConfigRef) =
-  if f.enabled: f.syms.add s
+template writeMangledName*(f: NdiFile; s: PSym; name: string, conf: ConfigRef) =
+  if f.enabled: f.syms.add (s, name)
 
 proc open*(f: var NdiFile; filename: AbsoluteFile; conf: ConfigRef) =
   f.enabled = not filename.isEmpty
@@ -53,8 +53,8 @@ proc close*(f: var NdiFile, conf: ConfigRef) =
   if f.enabled:
     f.f = open(f.filename.string, fmWrite, 8000)
     doAssert f.f != nil, f.filename.string
-    for s in f.syms:
-      doWrite(f, s, conf)
+    for (s, name) in f.syms:
+      doWrite(f, s, name, conf)
     close(f.f)
     f.syms.reset
     f.filename.reset
diff --git a/compiler/backend/cbackend.nim b/compiler/backend/cbackend.nim
index 8c931c9aa21..d0c0ae1651e 100644
--- a/compiler/backend/cbackend.nim
+++ b/compiler/backend/cbackend.nim
@@ -37,7 +37,8 @@ import
   ],
   compiler/ast/[
     ast,
-    lineinfos
+    lineinfos,
+    ndi
   ],
   compiler/backend/[
     backends,
@@ -93,6 +94,14 @@ type
 
 func hash(x: PSym): int = hash(x.id)
 
+proc writeMangledLocals(p: BProc) =
+  ## Writes the mangled names of `p`'s locals to the module's NDI file.
+  for it in p.locals.items:
+    # writing out mangled names for compiler-inserted variables (temporaries)
+    # is not necessary (lode is guaranteed to be a symbol)
+    if it.lode.sym.kind != skTemp:
+      writeMangledName(p.module.ndi, it.lode.sym, it.r, p.config)
+
 func registerInline(g: var InliningData, prc: PSym): uint32 =
   ## If not already registered, registers the inline procedure `prc` with
   ## `g`. This only sets up an ``InlineProc`` stub -- the entry is
@@ -237,7 +246,13 @@ proc processEvent(g: BModuleList, inl: var InliningData, discovery: var Discover
     bmod.declaredThings.incl(evt.sym.id)
     let
       body = generateAST(g.graph, bmod.idgen, evt.sym, evt.body)
-      r    = genProc(bmod, evt.sym, body)
+      p    = startProc(bmod, evt.sym, body)
+
+    # we can't generate with ``genProc`` because we still need to output
+    # the mangled names
+    genStmts(p, body)
+    writeMangledLocals(p)
+    let r = finishProc(p, evt.sym)
 
     if inlineId.isSome:
       # remember the generated body:
@@ -389,12 +404,35 @@ proc generateCode*(graph: ModuleGraph, g: BModuleList, mlist: sink ModuleList) =
 
   # finish the partial procedures:
   for s, p in partial.pairs:
+    writeMangledLocals(p)
     p.module.s[cfsProcs].add(finishProc(p, s))
 
   # -------------------------
   # all alive entities must have been discovered when reaching here; it is
   # not allowed to raise new ones beyond this point
 
+  block:
+    # write the mangled names of the various entities to the NDI files
+    for it in g.procs.items:
+      let
+        s = it.loc.lode.sym
+        m = g.modules[moduleId(s)]
+      writeMangledName(m.ndi, s, it.loc.r, g.config)
+      # parameters:
+      for p in it.params.items:
+        if p.k != locNone: # not all parameters have locs
+          writeMangledName(m.ndi, s, p.r, g.config)
+
+    template write(loc: TLoc) =
+      let s = loc.lode.sym
+      writeMangledName(g.modules[moduleId(s)].ndi, s, loc.r, g.config)
+
+    for it in g.globals.items:
+      write(it)
+
+    for it in g.consts.items:
+      write(it)
+
   # now emit a duplicate of each inline procedure into the C files where the
   # procedure is used. Due to how ``cgen`` currently works, this means
   # generating C code for the procedure again

From 473b1949b8fafb2a7b7df44e4232830cf7077507 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:16 +0000
Subject: [PATCH 5/8] cgen: less broad interface for the mangle procedures

This is made possible by them no longer requiring access to an NDI
file.
---
 compiler/backend/ccgexprs.nim |  2 +-
 compiler/backend/ccgtypes.nim | 14 +++++++-------
 compiler/backend/cgen.nim     |  5 +++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index cefd14d5783..8e712a71c7e 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -2138,7 +2138,7 @@ proc useConst*(m: BModule; sym: PSym) =
     m.s[cfsData].add(headerDecl)
 
 proc genConstDefinition*(q: BModule; sym: PSym) =
-  let name = mangleName(q, sym)
+  let name = mangleName(q.g.graph, sym)
   if lfNoDecl notin sym.locFlags:
     let p = newProc(nil, q)
     q.s[cfsData].addf("N_LIB_PRIVATE NIM_CONST $1 $2 = $3;$n",
diff --git a/compiler/backend/ccgtypes.nim b/compiler/backend/ccgtypes.nim
index 3c56c67d9ff..17509f7eb7b 100644
--- a/compiler/backend/ccgtypes.nim
+++ b/compiler/backend/ccgtypes.nim
@@ -33,23 +33,23 @@ proc mangleField(m: BModule; name: PIdent): string =
   if isKeyword(name):
     result.add "_0"
 
-proc mangleName(m: BModule; s: PSym): Rope =
+proc mangleName(g: ModuleGraph; s: PSym): Rope =
   result = s.extname
   if result == "":
     result = s.name.s.mangle.rope
     result.add "__"
-    result.add m.g.graph.ifaces[s.itemId.module].uniqueName
+    result.add g.ifaces[s.itemId.module].uniqueName
     result.add "_"
     result.add rope s.itemId.item
 
-proc mangleParamName(m: BModule; s: PSym): Rope =
-  ## we cannot use 'sigConflicts' here since we have a BModule, not a BProc.
+proc mangleParamName(c: ConfigRef; s: PSym): Rope =
+  ## we cannot use 'sigConflicts' here since we don't have access to a BProc.
   ## Fortunately C's scoping rules are sane enough so that that doesn't
   ## cause any trouble.
   result = s.extname
   if result == "":
     var res = s.name.s.mangle
-    if isKeyword(s.name) or m.g.config.cppDefines.contains(res):
+    if isKeyword(s.name) or c.cppDefines.contains(res):
       res.add "_0"
 
     result = res.rope
@@ -71,7 +71,7 @@ proc mangleLocalName(p: BProc; s: PSym): Rope =
     p.sigConflicts.inc(key)
 
 proc scopeMangledParam(p: BProc; param: PSym) =
-  ## parameter generation only takes BModule, not a BProc, so we have to
+  ## parameter generation doesn't have access to a ``BProc``, so we have to
   ## remember these parameter names are already in scope to be able to
   ## generate unique identifiers reliably (consider that ``var a = a`` is
   ## even an idiom in Nim).
@@ -380,7 +380,7 @@ proc prepareParameters(m: BModule, t: PType): seq[TLoc] =
       else:
         OnStack
 
-    result[i] = initLoc(locParam, params[i], mangleParamName(m, param),
+    result[i] = initLoc(locParam, params[i], mangleParamName(m.config, param),
                         storage)
 
     if ccgIntroducedPtr(m.config, param, t[0]):
diff --git a/compiler/backend/cgen.nim b/compiler/backend/cgen.nim
index c7c00c78e44..890affc5a3e 100644
--- a/compiler/backend/cgen.nim
+++ b/compiler/backend/cgen.nim
@@ -532,7 +532,7 @@ include ccgthreadvars
 proc varInDynamicLib(m: BModule, sym: PSym)
 
 proc fillGlobalLoc*(m: BModule, s: PSym, n: PNode) =
-  m.globals.put(s, initLoc(locGlobalVar, n, mangleName(m, s), OnHeap))
+  m.globals.put(s, initLoc(locGlobalVar, n, mangleName(m.g.graph, s), OnHeap))
 
 proc defineGlobalVar*(m: BModule, n: PNode) =
   let s = n.sym
@@ -568,7 +568,8 @@ proc fillProcLoc*(m: BModule; n: PNode) =
   let sym = n.sym
   if sym.locId == 0:
     m.procs.put(sym):
-      (initLoc(locProc, n, mangleName(m, sym), OnStack), (seq[TLoc])(@[]))
+      (initLoc(locProc, n, mangleName(m.g.graph, sym), OnStack),
+       (seq[TLoc])(@[]))
 
 proc getLabel(p: BProc): TLabel =
   inc(p.labels)

From 8af6d349efe4d191e35174691403b84e6b4dc2e7 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 20:20:17 +0000
Subject: [PATCH 6/8] cgmeth: fix the dispatcher AST

It stored in the name slot the symbol of the method that the dispatcher
was derived from, which now causes problems. With the fix, for all
routines reaching the backend, `sym.ast[namePos] == sym` *should* be
true.
---
 compiler/backend/cgmeth.nim | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/backend/cgmeth.nim b/compiler/backend/cgmeth.nim
index 631cee55e35..61c19c61b94 100644
--- a/compiler/backend/cgmeth.nim
+++ b/compiler/backend/cgmeth.nim
@@ -147,6 +147,7 @@ proc createDispatcher(s: PSym; g: ModuleGraph; idgen: IdGenerator): PSym =
   # we can't inline the dispatcher itself (for now):
   if disp.typ.callConv == ccInline: disp.typ.callConv = ccNimCall
   disp.ast = copyTree(s.ast)
+  disp.ast[namePos] = newSymNode(disp)
   disp.ast[bodyPos] = newNodeI(nkEmpty, s.info)
   disp.extname = ""
   if s.typ[0] != nil:

From 58d906d0c9fbb579ad949b2d0f72a095362b0f02 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sat, 8 Jul 2023 21:37:05 +0000
Subject: [PATCH 7/8] make the `tcan_compile_nim` test work

---
 compiler/backend/cgendata.nim |  4 ++--
 compiler/backend/jsgen.nim    | 11 +++++++----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/compiler/backend/cgendata.nim b/compiler/backend/cgendata.nim
index f3848f7d4ab..6b273048066 100644
--- a/compiler/backend/cgendata.nim
+++ b/compiler/backend/cgendata.nim
@@ -293,13 +293,13 @@ iterator cgenModules*(g: BModuleList): BModule =
     # iterate modules in the order they were closed
     yield m
 
-func put*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.}  =
+proc put*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.}  =
   ## Adds `it` to `m` and registers a mapping between the item and
   ## `sym`. `sym` must have no mapping registered yet.
   assert sym.locId == 0, "symbol already registered"
   sym.locId = uint32(m.store.add(it)) + 1
 
-func forcePut*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.} =
+proc forcePut*[T](m: var SymbolMap[T], sym: PSym, it: sink T) {.inline.} =
   ## Adds `it` to `m` and register a mapping between the item and
   ## `sym`, overwriting any existing mappings of `sym`.
   sym.locId = uint32(m.store.add(it)) + 1
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index b23baa03663..3b847ece8df 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -275,9 +275,12 @@ func mangleName(m: BModule, s: PSym): Rope =
       result.add("_")
       result.add(rope(s.id))
 
-proc mangledName(p: PProc, s: PSym, info: TLineInfo): lent string =
-  template get(tbl: untyped): untyped =
-    p.config.internalAssert(s.id in tbl, info):
+proc mangledName(p: PProc, s: PSym, info: TLineInfo): string =
+  ## Returns the cached JavaScript name for `s`.
+  ## At the time of writing, a borrowed string (``lent string``) from
+  ## can't be returned because of compiler shortcomings.
+  template get(tbl: untyped): string =
+    p.module.config.internalAssert(s.id in tbl, info):
       "symbol has no generated name: " & s.name.s
     tbl[s.id]
 
@@ -305,7 +308,7 @@ proc ensureMangledName(p: PProc, s: PSym): lent string =
     # the mangled named hasn't been generated yet
     n[] = mangleName(p.module, s)
 
-  result = n[]
+  result = p.g.names[s.id]
 
 proc escapeJSString(s: string): string =
   result = newStringOfCap(s.len + s.len shr 2)

From 356ee71afbaed3c217dd33d1b815b8289a818e96 Mon Sep 17 00:00:00 2001
From: zerbina <100542850+zerbina@users.noreply.github.com>
Date: Sun, 9 Jul 2023 16:21:53 +0200
Subject: [PATCH 8/8] apply suggestions from code review

Co-authored-by: Saem Ghani <saemghani+github@gmail.com>
---
 compiler/backend/ccgstmts.nim | 2 +-
 compiler/backend/ccgtypes.nim | 4 ++--
 compiler/backend/jsgen.nim    | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/backend/ccgstmts.nim b/compiler/backend/ccgstmts.nim
index 9d7a6ad4b90..0e4f1279405 100644
--- a/compiler/backend/ccgstmts.nim
+++ b/compiler/backend/ccgstmts.nim
@@ -169,7 +169,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
 
   if value.kind != nkEmpty:
     genLineDir(p, vn)
-    # we have an parameter aliasing issue here: passing `p.locals[v]`
+    # we have a parameter aliasing issue here: passing `p.locals[v]`
     # as the parameter directly would be an aliasing rule violation.
     # Since the initializer expression cannot reference `v` itself,
     # it's safe to temporarily move the loc out of ``p.locals``
diff --git a/compiler/backend/ccgtypes.nim b/compiler/backend/ccgtypes.nim
index 17509f7eb7b..ff7d1e2aab9 100644
--- a/compiler/backend/ccgtypes.nim
+++ b/compiler/backend/ccgtypes.nim
@@ -493,8 +493,8 @@ proc genRecordFieldsAux(m: BModule, n: PNode,
     if field.locId == 0:
       # XXX: the C struct definition for the type is re-generated in every C
       #      file the type is used in, so the field might have an associated
-      #      loc. Eventually, each C type is only generated once, and then the
-      #      guard can be removed
+      #      loc. Eventually, each C type will only be generated once, and then
+      #      the guard can be removed
       m.fields.put(field):
         initLoc(locField, n, unionPrefix & sname, OnUnknown)
 
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index 3b847ece8df..e34ce01ecb4 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -277,7 +277,7 @@ func mangleName(m: BModule, s: PSym): Rope =
 
 proc mangledName(p: PProc, s: PSym, info: TLineInfo): string =
   ## Returns the cached JavaScript name for `s`.
-  ## At the time of writing, a borrowed string (``lent string``) from
+  ## At the time of writing, a borrowed string (``lent string``)
   ## can't be returned because of compiler shortcomings.
   template get(tbl: untyped): string =
     p.module.config.internalAssert(s.id in tbl, info):