diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index 256431a7165..5b0d3400ffa 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -906,15 +906,6 @@ proc genStrAppend(p: BProc, e: CgNode, d: var TLoc) =
           [byRefLoc(p, dest), lens, L])
   p.s(cpsStmts).add appends
 
-proc genReset(p: BProc, n: CgNode) =
-  var a: TLoc
-  initLocExpr(p, n[1], a)
-  specializeReset(p, a)
-  when false:
-    linefmt(p, cpsStmts, "#genericReset((void*)$1, $2);$n",
-            [addrLoc(p.config, a),
-            genTypeInfoV1(p.module, skipTypes(a.t, {tyVar}), n.info)])
-
 proc genDefault(p: BProc; n: CgNode; d: var TLoc) =
   if d.k == locNone: getTemp(p, n.typ, d, needsInit=true)
   else: resetLoc(p, d)
@@ -983,9 +974,6 @@ proc handleConstExpr(p: BProc, n: CgNode, d: var TLoc): bool =
   else:
     result = false
 
-# XXX: maybe move the `specializeInitObject` procs into a separate module
-#      (similiar to `specializeReset`)
-
 proc specializeInitObject(p: BProc, accessor: Rope, typ: PType,
                           info: TLineInfo)
 
@@ -1074,7 +1062,7 @@ proc specializeInitObject(p: BProc, accessor: Rope, typ: PType,
       if t.n != nil and searchTypeNodeFor(t.n, pred):
         specializeInitObjectN(p, a, t.n, t)
 
-      a = parentObj(a)
+      a.add ".Sup"
       t = t.base
 
     # type header:
@@ -1864,7 +1852,6 @@ proc genMagicExpr(p: BProc, e: CgNode, d: var TLoc, op: TMagic) =
 
     genCall(p, e, d)
   of mDefault: genDefault(p, e, d)
-  of mReset: genReset(p, e)
   of mEcho: genEcho(p, e[1].skipConv)
   of mArrToSeq: genArrToSeq(p, e, d)
   of mNLen..mNError, mSlurp..mQuoteAst:
diff --git a/compiler/backend/ccgreset.nim b/compiler/backend/ccgreset.nim
deleted file mode 100644
index 28f2e6f1b70..00000000000
--- a/compiler/backend/ccgreset.nim
+++ /dev/null
@@ -1,98 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2020 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-# included from cgen.nim
-
-## Code specialization instead of the old, incredibly slow 'genericReset'
-## implementation.
-
-proc genCaseRange(p: BProc, branch: PNode|CgNode)
-proc getTemp(p: BProc, t: PType, result: var TLoc; needsInit=false)
-
-proc specializeResetT(p: BProc, accessor: Rope, typ: PType)
-
-proc parentObj(accessor: Rope): Rope {.inline.} =
-  result = "$1.Sup" % [accessor]
-
-proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
-                     typ: PType) =
-  if n == nil: return
-  case n.kind
-  of nkRecList:
-    for i in 0..<n.len:
-      specializeResetN(p, accessor, n[i], typ)
-  of nkRecCase:
-    p.config.internalAssert(n[0].kind == nkSym, n.info, "specializeResetN")
-    let disc = n[0].sym
-    ensureObjectFields(p.module, disc, typ)
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, p.fieldName(disc)])
-    for i in 1..<n.len:
-      let branch = n[i]
-      assert branch.kind in {nkOfBranch, nkElse}
-      if branch.kind == nkOfBranch:
-        genCaseRange(p, branch)
-      else:
-        lineF(p, cpsStmts, "default:$n", [])
-      specializeResetN(p, accessor, lastSon(branch), typ)
-      lineF(p, cpsStmts, "break;$n", [])
-    lineF(p, cpsStmts, "} $n", [])
-    specializeResetT(p, "$1.$2" % [accessor, p.fieldName(disc)], disc.typ)
-  of nkSym:
-    let field = n.sym
-    if field.typ.kind == tyVoid: return
-    ensureObjectFields(p.module, field, typ)
-    specializeResetT(p, "$1.$2" % [accessor, p.fieldName(field)], field.typ)
-  else: internalError(p.config, n.info, "specializeResetN()")
-
-proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
-  if typ == nil: return
-
-  case typ.kind
-  of tyGenericInst, tyGenericBody, tyTypeDesc, tyAlias, tyDistinct, tyInferred,
-     tySink:
-    specializeResetT(p, accessor, lastSon(typ))
-  of tyArray:
-    let arraySize = lengthOrd(p.config, typ[0])
-    var i: TLoc
-    getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt), i)
-    linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
-            [i.r, arraySize])
-    specializeResetT(p, ropecg(p.module, "$1[$2]", [accessor, i.r]), typ[1])
-    lineF(p, cpsStmts, "}$n", [])
-  of tyObject:
-    for i in 0..<typ.len:
-      var x = typ[i]
-      if x != nil: x = x.skipTypes(skipPtrs)
-      specializeResetT(p, parentObj(accessor), x)
-    if typ.n != nil: specializeResetN(p, accessor, typ.n, typ)
-  of tyTuple:
-    let typ = getUniqueType(typ)
-    for i in 0..<typ.len:
-      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), typ[i])
-
-  of tyRef:
-    lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
-  of tyString, tySequence:
-    lineCg(p, cpsStmts, "$1.len = 0;$n", [accessor])
-    lineCg(p, cpsStmts, "$1.data = NIM_NIL;$n", [accessor])
-  of tyProc:
-    if typ.callConv == ccClosure:
-      lineCg(p, cpsStmts, "$1.ClE_0 = NIM_NIL;$n", [accessor])
-      lineCg(p, cpsStmts, "$1.ClP_0 = NIM_NIL;$n", [accessor])
-    else:
-      lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
-  of tyChar, tyBool, tyEnum, tyInt..tyUInt64:
-    lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
-  of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
-    lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
-  else:
-    discard
-
-proc specializeReset(p: BProc, a: TLoc) =
-  specializeResetT(p, rdLoc(a), a.t)
diff --git a/compiler/backend/cgen.nim b/compiler/backend/cgen.nim
index 1ca80ef04ea..0e294c44c89 100644
--- a/compiler/backend/cgen.nim
+++ b/compiler/backend/cgen.nim
@@ -410,8 +410,6 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: TLoc,
         let tmp = defaultValueExpr(p, t, a.lode.info)
         genAssignment(p, a, tmp)
 
-include ccgreset
-
 proc constructLoc(p: BProc, loc: var TLoc, isTemp = false; doInitObj = true) =
   let kind = mapTypeChooser(loc)
   case mapType(p.config, loc.t, kind)
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index ef4c743195c..3316b093899 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -2006,7 +2006,7 @@ proc genMagic(p: PProc, n: CgNode, r: var TCompRes) =
   of mNewSeqOfCap: unaryExpr(p, n, r, "", "[]")
   of mOf: genOf(p, n, r)
   of mDefault: genDefault(p, n, r)
-  of mReset, mWasMoved: genReset(p, n)
+  of mWasMoved: genReset(p, n)
   of mEcho: genEcho(p, n, r)
   of mNLen..mNError, mSlurp, mStaticExec:
     localReport(p.config, n.info, reportSym(
diff --git a/compiler/vm/vmgen.nim b/compiler/vm/vmgen.nim
index b1c98434dc2..b4bd1b741fd 100644
--- a/compiler/vm/vmgen.nim
+++ b/compiler/vm/vmgen.nim
@@ -1812,7 +1812,7 @@ proc genMagic(c: var TCtx; n: CgNode; dest: var TDest; m: TMagic) =
     c.freeTemp(tmp1)
     c.freeTemp(tmp2)
     c.freeTemp(tmp3)
-  of mReset, mWasMoved:
+  of mWasMoved:
     unused(c, n, dest)
     let
       (dest, isDirect) = genNoLoad(c, n[1])