diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index dc62e7c818..ba7e1500e3 100644
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -2901,22 +2901,6 @@ proc genDestroy(p: BProc; n: PNode) =
       internalError(p.config, n.info, "destructor turned out to be not trivial")
     discard "ignore calls to the default destructor"
 
-proc genDispose(p: BProc; n: PNode) =
-  when false:
-    let elemType = n[1].typ.skipTypes(abstractVar).elementType
-
-    var a: TLoc = initLocExpr(p, n[1].skipAddr)
-
-    if isFinal(elemType):
-      if elemType.destructor != nil:
-        var destroyCall = newNodeI(nkCall, n.info)
-        genStmts(p, destroyCall)
-      lineFmt(p, cpsStmts, "#nimRawDispose($1, NIM_ALIGNOF($2))", [rdLoc(a), getTypeDesc(p.module, elemType)])
-    else:
-      # ``nimRawDisposeVirtual`` calls the ``finalizer`` which is the same as the
-      # destructor, but it uses the runtime type. Afterwards the memory is freed:
-      lineCg(p, cpsStmts, ["#nimDestroyAndDispose($#)", rdLoc(a)])
-
 proc genSlice(p: BProc; e: PNode; d: var TLoc) =
   let (x, y) = genOpenArraySlice(p, e, e.typ, e.typ.elementType,
     prepareForMutation = e[1].kind == nkHiddenDeref and
@@ -3490,7 +3474,6 @@ proc genConstHeader(m, q: BModule; p: BProc, sym: PSym) =
     m.initProc.procSec(cpsLocals).add('\t')
     m.initProc.procSec(cpsLocals).addAssignmentWithValue(sym.loc.snippet):
       m.initProc.procSec(cpsLocals).addCast(ptrType(getTypeDesc(m, sym.loc.t, dkVar))):
-        var getGlobalCall: CallBuilder
         m.initProc.procSec(cpsLocals).addCall("hcrGetGlobal",
           getModuleDllPath(q, sym),
           '"' & sym.loc.snippet & '"')
@@ -3768,7 +3751,6 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
     if delayedCodegen(p.module):
       genConstStmt(p, n)
     else: # enforce addressable consts for exportc
-      let m = p.module
       for it in n:
         let symNode = skipPragmaExpr(it.firstSon)
         if symNode.kind == nkSym and sfExportc in symNode.sym.flags:
diff --git a/compiler/ccgliterals.nim b/compiler/ccgliterals.nim
index 0a1586ae29..ddedabf6ad 100644
--- a/compiler/ccgliterals.nim
+++ b/compiler/ccgliterals.nim
@@ -28,9 +28,6 @@ proc detectStrVersion(m: BModule): int =
   else:
     detectVersion(strVersion, "nimStrVersion")
 
-proc detectSeqVersion(m: BModule): int =
-  detectVersion(seqVersion, "nimSeqVersion")
-
 # ----- Version 1: GC'ed strings and seqs --------------------------------
 
 proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
@@ -132,25 +129,6 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Bu
     result.addField(strInit, name = "p"):
       result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
 
-proc ssoCharLit(ch: char): string =
-  ## Return a C char literal for ch, with proper escaping.
-  const hexDigits = "0123456789abcdef"
-  result = "'"
-  case ch
-  of '\'': result.add("\\'")
-  of '\\': result.add("\\\\")
-  of '\0': result.add("\\0")
-  of '\n': result.add("\\n")
-  of '\r': result.add("\\r")
-  of '\t': result.add("\\t")
-  elif ch.ord < 32 or ch.ord == 127:
-    result.add("\\x")
-    result.add(hexDigits[ch.ord shr 4])
-    result.add(hexDigits[ch.ord and 0xf])
-  else:
-    result.add(ch)
-  result.add('\'')
-
 proc ssoBytesLit(m: BModule; s: string; slen: int): string =
   ## Compute the `bytes` field value for the new SmallString layout.
   ## byte 0 = slen, bytes 1-7 = inline chars 0-6 (zero-padded).
@@ -320,19 +298,6 @@ proc genStringLiteralV3(m: BModule; n: PNode; isConst: bool; result: var Builder
 
 # ------ Version selector ---------------------------------------------------
 
-proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
-                              isConst: bool; result: var Rope) =
-  case detectStrVersion(m)
-  of 0, 1: genStringLiteralDataOnlyV1(m, s, result)
-  of 2:
-    let tmp = getTempName(m)
-    genStringLiteralDataOnlyV2(m, s, tmp, isConst)
-    result.add tmp
-  of 3:
-    localError(m.config, info, "genStringLiteralDataOnly not supported for SmallString (nimsso)")
-  else:
-    localError(m.config, info, "cannot determine how to produce code for string literal")
-
 proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Builder) =
   result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
 
diff --git a/compiler/ccgstmts.nim b/compiler/ccgstmts.nim
index cffee9c77d..f4c6cfab9e 100644
--- a/compiler/ccgstmts.nim
+++ b/compiler/ccgstmts.nim
@@ -1354,92 +1354,6 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
     linefmt(p, cpsStmts, "if (T$1_) std::rethrow_exception(T$1_);$n", [etmp])
     endSimpleBlock(p, scope)
 
-proc genTryCppOld(p: BProc, t: PNode, d: var TLoc) =
-  # There are two versions we generate, depending on whether we
-  # catch C++ exceptions, imported via .importcpp or not. The
-  # code can be easier if there are no imported C++ exceptions
-  # to deal with.
-
-  # code to generate:
-  #
-  #   try
-  #   {
-  #      myDiv(4, 9);
-  #   } catch (NimExceptionType1&) {
-  #      body
-  #   } catch (NimExceptionType2&) {
-  #      finallyPart()
-  #      raise;
-  #   }
-  #   catch(...) {
-  #     general_handler_body
-  #   }
-  #   finallyPart();
-
-  template genExceptBranchBody(body: PNode) {.dirty.} =
-    genRestoreFrameAfterException(p)
-    expr(p, body, d)
-
-  if not isEmptyType(t.typ) and d.k == locNone:
-    d = getTemp(p, t.typ)
-  genLineDir(p, t)
-  cgsym(p.module, "popCurrentExceptionEx")
-  let fin = if t[^1].kind == nkFinally: t[^1] else: nil
-  p.nestedTryStmts.add((fin, false, t.kind == nkHiddenTryStmt, 0.Natural))
-  startBlockWith(p):
-    p.s(cpsStmts).add("try {\n")
-  expr(p, t.firstSon, d)
-  endBlockWith(p):
-    p.s(cpsStmts).add("}\n")
-
-  var catchAllPresent = false
-
-  p.nestedTryStmts[^1].inExcept = true
-  for i in 1..<t.len:
-    if t[i].kind != nkExceptBranch: break
-
-    # bug #4230: avoid false sharing between branches:
-    if d.k == locTemp and isEmptyType(t.typ): d.k = locNone
-
-    if t[i].len == 1:
-      # general except section:
-      catchAllPresent = true
-      startBlockWith(p):
-        p.s(cpsStmts).add("catch (...) {\n")
-      genExceptBranchBody(t[i].firstSon)
-      endBlockWith(p):
-        p.s(cpsStmts).add("}\n")
-    else:
-      for j in 0..<t[i].len-1:
-        if t[i][j].isInfixAs():
-          let exvar = t[i][j][2] # ex1 in `except ExceptType as ex1:`
-          fillLocalName(p, exvar.sym)
-          backendEnsureMutable exvar.sym
-          fillLoc(exvar.sym.locImpl, locTemp, exvar, OnUnknown)
-          startBlockWith(p):
-            lineCg(p, cpsStmts, "catch ($1& $2) {$n", [getTypeDesc(p.module, t[i][j][1].typ), rdLoc(exvar.sym.loc)])
-        else:
-          startBlockWith(p):
-            lineCg(p, cpsStmts, "catch ($1&) {$n", [getTypeDesc(p.module, t[i][j].typ)])
-        genExceptBranchBody(t[i][^1])  # exception handler body will duplicated for every type
-        endBlockWith(p):
-          p.s(cpsStmts).add("}\n")
-
-  discard pop(p.nestedTryStmts)
-
-  if t[^1].kind == nkFinally:
-    # c++ does not have finally, therefore code needs to be generated twice
-    if not catchAllPresent:
-      # finally requires catch all presence
-      startBlockWith(p):
-        p.s(cpsStmts).add("catch (...) {\n")
-      genStmts(p, t[^1].firstSon)
-      line(p, cpsStmts, "throw;\n")
-      endBlockWith(p):
-        p.s(cpsStmts).add("}\n")
-
-    genSimpleBlock(p, t[^1].firstSon)
-
 proc bodyCanRaise(p: BProc; n: PNode): bool =
   case n.kind
   of nkCallKinds:
diff --git a/compiler/ccgtypes.nim b/compiler/ccgtypes.nim
index dbaf9fcd7c..36238d717d 100644
--- a/compiler/ccgtypes.nim
+++ b/compiler/ccgtypes.nim
@@ -1461,8 +1461,6 @@ proc discriminatorTableName(m: BModule; objtype: PType, d: PSym): Rope =
     internalError(m.config, d.info, "anonymous obj with discriminator")
   result = "NimDT_$1_$2" % [rope($hashType(objtype, m.config)), rope(d.name.s.mangle)]
 
-proc rope(arg: Int128): Rope = rope($arg)
-
 proc discriminatorTableDecl(m: BModule; objtype: PType, d: PSym, result: var Builder) =
   cgsym(m, "TNimNode")
   var tmp = discriminatorTableName(m, objtype, d)
diff --git a/compiler/cgen.nim b/compiler/cgen.nim
index 9f84920e9e..4cdd86347a 100644
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -1895,10 +1895,6 @@ proc getFileHeader(conf: ConfigRef; cfile: Cfile): Rope =
   addNimDefines(res, conf)
   result = extract(res)
 
-proc getSomeNameForModule(conf: ConfigRef, filename: AbsoluteFile): Rope =
-  ## Returns a mangled module name.
-  result = mangleModuleName(conf, filename).mangle
-
 proc getSomeNameForModule*(m: BModule): Rope =
   ## Returns a mangled module name.
   assert m.module.kind == skModule
@@ -2354,7 +2350,6 @@ proc hcrGetProcLoadCode(builder: var Builder, m: BModule, sym, prefix, handle, g
   assert prc != nil
   fillProcLoc(m, prc.ast[namePos])
 
-  var extname = prefix & sym
   var tmp = mangleDynLibProc(prc)
   backendEnsureMutable prc
   prc.locImpl.snippet = tmp
@@ -2836,15 +2831,6 @@ proc writeModule(m: BModule) =
     code = stripCnifMarks(code)
   registerModuleCode(m, cf, code)
 
-proc updateCachedModule(m: BModule) =
-  let cfile = getCFile(m)
-  var cf = Cfile(nimname: m.module.name.s, cname: cfile,
-                 obj: completeCfilePath(m.config, toObjFile(m.config, cfile)), flags: {})
-  if sfMainModule notin m.module.flags:
-    genMainProc(m)
-  cf.flags = {CfileFlag.Cached}
-  addFileToCompile(m.config, cf)
-
 proc generateLibraryDestroyGlobals(graph: ModuleGraph; m: BModule; body: PNode; isDynlib: bool): PSym =
   let prefixedName = m.config.nimMainPrefix & "NimDestroyGlobals"
   let procname = getIdent(graph.cache, prefixedName)
diff --git a/compiler/concepts.nim b/compiler/concepts.nim
index 4f531c2cf9..89a301e03f 100644
--- a/compiler/concepts.nim
+++ b/compiler/concepts.nim
@@ -269,10 +269,8 @@ proc conceptsMatch(c: PContext, fc, ac: PType; m: var MatchCon): MatchKind =
   let
     fn = fc.conceptBody
     an = ac.conceptBody
-    sameLen = fc.len == ac.len
   var match = false
   for fdef in fn:
-    var cmpResult = false
     for ia, ndef in an:
       match = cmpConceptDefs(c, fdef, ndef, m)
       if match:
@@ -330,13 +328,10 @@ proc matchType(c: PContext; fo, ao: PType; m: var MatchCon): bool =
     result = matchType(c, f.skipModifier, a, m)
   of tyTypeDesc:
     if isSelf(f):
-      let ua = a.skipTypes(asymmetricConceptParamMods)
       if m.magic in {mArrPut, mArrGet}:
         if m.potentialImplementation.reduceToBase.kind in arrPutGetMagicApplies:
           bindParam(c, m, a, last m.potentialImplementation)
           result = true
-      #elif ua.isConcept:
-      #  result = matchType(c, m.concpt, ua, m)
       else:
         result = matchType(c, a.skipTypes(ignorableForArgType), m.potentialImplementation, m)
     else:
diff --git a/compiler/docgen.nim b/compiler/docgen.nim
index 71af95a5f2..e009d06f22 100644
--- a/compiler/docgen.nim
+++ b/compiler/docgen.nim
@@ -425,12 +425,6 @@ template dispA(conf: ConfigRef; dest: var string, xml, tex: string,
   if not conf.isLatexCmd: dest.addf(xml, args)
   else: dest.addf(tex, args)
 
-proc getVarIdx(varnames: openArray[string], id: string): int =
-  for i in 0..high(varnames):
-    if cmpIgnoreStyle(varnames[i], id) == 0:
-      return i
-  result = -1
-
 proc genComment(d: PDoc, n: PNode): PRstNode =
   if n.comment.len > 0:
     if optDocRaw in d.conf.globalOptions:
diff --git a/compiler/docgen2.nim b/compiler/docgen2.nim
index 7fb11a3bd7..1d5434879c 100644
--- a/compiler/docgen2.nim
+++ b/compiler/docgen2.nim
@@ -29,7 +29,6 @@ proc shouldProcess(g: PGen): bool =
 template closeImpl(body: untyped) {.dirty.} =
   var g = PGen(p)
   let useWarning = sfMainModule notin g.module.flags
-  let groupedToc = true
   if shouldProcess(g):
     finishGenerateDoc(g.doc)
     body
@@ -41,7 +40,7 @@ template closeImpl(body: untyped) {.dirty.} =
 proc closeDoc*(graph: ModuleGraph; p: PPassContext, n: PNode): PNode =
   result = nil
   closeImpl:
-    writeOutput(g.doc, useWarning, groupedToc)
+    writeOutput(g.doc, useWarning, true)
 
 proc closeJson*(graph: ModuleGraph; p: PPassContext, n: PNode): PNode =
   result = nil
diff --git a/compiler/injectdestructors.nim b/compiler/injectdestructors.nim
index 37969dfd31..bc99008a0d 100644
--- a/compiler/injectdestructors.nim
+++ b/compiler/injectdestructors.nim
@@ -173,7 +173,6 @@ template hasDestructorOrAsgn(c: var Con, typ: PType): bool =
 proc isLastRead(n: PNode; c: var Con; s: var Scope): bool =
   if not hasDestructorOrAsgn(c, n.typ): return true
 
-  let m = skipConvDfa(n)
   result = isLastReadImpl(n, c, s)
 
 proc isFirstWrite(n: PNode; c: var Con): bool =
diff --git a/compiler/int128.nim b/compiler/int128.nim
index cc253fb682..4b1f7f3a7a 100644
--- a/compiler/int128.nim
+++ b/compiler/int128.nim
@@ -340,9 +340,6 @@ proc `*`*(a: Int128, b: int32): Int128 =
   if b < 0:
     result = -result
 
-proc `*=`(a: var Int128, b: int32) =
-  a = a * b
-
 proc makeInt128(high, low: uint64): Int128 =
   result = Zero
   result.udata[0] = cast[uint32](low)
diff --git a/compiler/jsgen.nim b/compiler/jsgen.nim
index a04c8e8f95..963c147fac 100644
--- a/compiler/jsgen.nim
+++ b/compiler/jsgen.nim
@@ -148,11 +148,6 @@ proc newGlobals(): PGlobals =
         typeInfoGenerated: initIntSet()
         )
 
-proc initCompRes(): TCompRes =
-  result = TCompRes(address: "", res: "",
-    tmpLoc: "", typ: etyNone, kind: resNone
-  )
-
 proc rdLoc(a: TCompRes): Rope {.inline.} =
   if a.typ != etyBaseIndex:
     result = a.res
@@ -594,15 +589,6 @@ proc binaryUintExpr(p: PProc, n: PNode, r: var TCompRes, op: string,
       r.res = "(($1 $2 $3) $4)" % [x.rdLoc, rope op, y.rdLoc, trimmer]
   r.kind = resExpr
 
-template ternaryExpr(p: PProc, n: PNode, r: var TCompRes, magic, frmt: string) =
-  var x, y, z: TCompRes
-  useMagic(p, magic)
-  gen(p, n[1], x)
-  gen(p, n[2], y)
-  gen(p, n[3], z)
-  r.res = frmt % [x.rdLoc, y.rdLoc, z.rdLoc]
-  r.kind = resExpr
-
 template unaryExpr(p: PProc, n: PNode, r: var TCompRes, magic, frmt: string) =
   # $1 binds to n[1], if $2 is present it will be substituted to a tmp of $1
   useMagic(p, magic)
@@ -1182,7 +1168,6 @@ proc genAsmOrEmitStmt(p: PProc, n: PNode; isAsmStmt = false) =
     of nkStrLit..nkTripleStrLit:
       p.body.add(it.strVal)
     of nkSym:
-      let v = it.sym
       # for backwards compatibility we don't deref syms here :-(
       if false:
         discard
@@ -1255,17 +1240,6 @@ proc generateHeader(p: PProc, prc: PSym): Rope =
       result.add(name)
       result.add("_Idx")
 
-proc countJsParams(typ: PType): int =
-  result = 0
-  for i in 1..<typ.n.len:
-    assert(typ.n[i].kind == nkSym)
-    var param = typ.n[i].sym
-    if isCompileTimeOnly(param.typ): continue
-    if mapType(param.typ) == etyBaseIndex:
-      inc result, 2
-    else:
-      inc result
-
 const
   nodeKindsNeedNoCopy = {nkCharLit..nkInt64Lit, nkStrLit..nkTripleStrLit,
     nkFloatLit..nkFloat64Lit, nkPar, nkStringToCString,
@@ -1797,12 +1771,6 @@ proc genArgs(p: PProc, n: PNode, r: var TCompRes; start=1) =
     inc emitted
     hasArgs = true
   r.res.add(")")
-  when false:
-    # XXX look into this:
-    let jsp = countJsParams(typ)
-    if emitted != jsp and tfVarargs notin typ.flags:
-      localError(p.config, n.info, "wrong number of parameters emitted; expected: " & $jsp &
-        " but got: " & $emitted)
   r.kind = resExpr
 
 proc genOtherArg(p: PProc; n: PNode; i: int; typ: PType;
@@ -2335,9 +2303,6 @@ proc genJSArrayConstr(p: PProc, n: PNode, r: var TCompRes) =
   r.res.add("]")
 
 proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
-  var
-    a: TCompRes
-    line, filen: Rope
   var op = n[0].sym.magic
   case op
   of mOr: genOr(p, n[1], n[2], r)
@@ -2594,7 +2559,6 @@ proc genObjConstr(p: PProc, n: PNode, r: var TCompRes) =
   r.kind = resExpr
   var initList : Rope = ""
   var fieldIDs = initIntSet()
-  let nTyp = n.typ.skipTypes(abstractInst)
   for i in 1..<n.len:
     if i > 1: initList.add(", ")
     var it = n[i]
diff --git a/compiler/lambdalifting.nim b/compiler/lambdalifting.nim
index 21571de254..c1994a962d 100644
--- a/compiler/lambdalifting.nim
+++ b/compiler/lambdalifting.nim
@@ -126,11 +126,6 @@ const
   paramName* = ":envP"
   envName* = ":env"
 
-proc newCall(a: PSym, b: PNode): PNode =
-  result = newNodeI(nkCall, a.info)
-  result.add newSymNode(a)
-  result.add b
-
 proc createClosureIterStateType*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PType =
   var n = newNodeI(nkRange, iter.info)
   n.add newIntNode(nkIntLit, -1)
@@ -288,7 +283,6 @@ proc liftIterSym*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PN
     addVar(v, env)
     result.add(v)
   # add 'new' statement:
-  #result.add newCall(getSysSym(g, n.info, "internalNew"), env)
   result.add genCreateEnv(env)
   createTypeBoundOpsLL(g, env.typ, n.info, idgen, owner)
   result.add makeClosure(g, idgen, iter, env, n.info)
diff --git a/compiler/lexer.nim b/compiler/lexer.nim
index bc94542cc2..b05041ef1a 100644
--- a/compiler/lexer.nim
+++ b/compiler/lexer.nim
@@ -735,17 +735,11 @@ proc getEscapedChar(L: var Lexer, tok: var Token) =
   else: lexMessage(L, errGenerated, "invalid character constant")
 
 proc handleCRLF(L: var Lexer, pos: int): int =
-  template registerLine =
-    let col = L.getColNumber(pos)
-
-  case L.buf[pos]
-  of CR:
-    registerLine()
-    result = nimlexbase.handleCR(L, pos)
-  of LF:
-    registerLine()
-    result = nimlexbase.handleLF(L, pos)
-  else: result = pos
+  result =
+    case L.buf[pos]
+    of CR: nimlexbase.handleCR(L, pos)
+    of LF: nimlexbase.handleLF(L, pos)
+    else: pos
 
 type
   StringMode = enum
diff --git a/compiler/liftdestructors.nim b/compiler/liftdestructors.nim
index 032a4623f2..caba4b2600 100644
--- a/compiler/liftdestructors.nim
+++ b/compiler/liftdestructors.nim
@@ -596,12 +596,6 @@ proc newSeqCall(c: var TLiftCtx; x, y: PNode): PNode =
   lenCall.typ = getSysType(c.g, x.info, tyInt)
   result.add lenCall
 
-proc setLenStrCall(c: var TLiftCtx; x, y: PNode): PNode =
-  let lenCall = genBuiltin(c, mLengthStr, "len", y)
-  lenCall.typ = getSysType(c.g, x.info, tyInt)
-  result = genBuiltin(c, mSetLengthStr, "setLen", x) # genAddr(g, x))
-  result.add lenCall
-
 proc setLenSeqCall(c: var TLiftCtx; t: PType; x, y: PNode; noinit = false): PNode =
   let lenCall = genBuiltin(c, mLengthSeq, "len", y)
   lenCall.typ = getSysType(c.g, x.info, tyInt)
diff --git a/compiler/main.nim b/compiler/main.nim
index e27960f589..0365eba486 100644
--- a/compiler/main.nim
+++ b/compiler/main.nim
@@ -209,22 +209,6 @@ proc commandInteractive(graph: ModuleGraph) =
     let s = llStreamOpenStdIn(onPrompt = proc() = flushDot(graph.config))
     discard processPipelineModule(graph, m, idgen, s)
 
-proc commandScan(cache: IdentCache, config: ConfigRef) =
-  var f = addFileExt(AbsoluteFile mainCommandArg(config), NimExt)
-  var stream = llStreamOpen(f, fmRead)
-  if stream != nil:
-    var
-      L: Lexer = default(Lexer)
-      tok: Token = default(Token)
-    openLexer(L, f, stream, cache, config)
-    while true:
-      rawGetTok(L, tok)
-      printTok(config, tok)
-      if tok.tokType == tkEof: break
-    closeLexer(L)
-  else:
-    rawMessage(config, errGenerated, "cannot open file: " & f.string)
-
 const
   PrintRopeCacheStats = false
 
diff --git a/compiler/modulegraphs.nim b/compiler/modulegraphs.nim
index 7b975268cd..6e8715c837 100644
--- a/compiler/modulegraphs.nim
+++ b/compiler/modulegraphs.nim
@@ -432,10 +432,6 @@ proc addDispatchers*(g: ModuleGraph, value: PSym) =
   # TODO: add it for packed modules
   g.dispatchers.add value
 
-iterator resolveLazySymSeq(g: ModuleGraph, list: var seq[PSym]): PSym =
-  for it in list.mitems:
-    yield it
-
 proc setMethodsPerType*(g: ModuleGraph; id: ItemId, methods: seq[PSym]) =
   # TODO: add it for packed modules
   g.methodsPerType[id] = methods
@@ -668,10 +664,6 @@ proc hash*(u: SigHash): Hash =
 
 proc hash*(x: FileIndex): Hash {.borrow.}
 
-template getPContext(): untyped =
-  when c is PContext: c
-  else: c.c
-
 when defined(nimsuggest):
   template onUse*(info: TLineInfo; s: PSym; isGenericInstance = false) = discard
   template onDefResolveForward*(info: TLineInfo; s: PSym) = discard
diff --git a/compiler/msgs.nim b/compiler/msgs.nim
index 8c3ef55423..cb9195bec8 100644
--- a/compiler/msgs.nim
+++ b/compiler/msgs.nim
@@ -24,10 +24,6 @@ template instLoc*(): InstantiationInfo = instantiationInfo(-2, fullPaths = true)
 template toStdOrrKind(stdOrr): untyped =
   if stdOrr == stdout: stdOrrStdout else: stdOrrStderr
 
-proc toLowerAscii(a: var string) {.inline.} =
-  for c in mitems(a):
-    if isUpperAscii(c): c = char(uint8(c) xor 0b0010_0000'u8)
-
 proc flushDot*(conf: ConfigRef) =
   ## safe to call multiple times
   let stdOrr = if optStdout in conf.globalOptions: stdout else: stderr
@@ -83,7 +79,8 @@ proc canonicalCase(path: var string) {.inline.} =
   ## the idea is to only use this for checking whether a path is already in
   ## the table but otherwise keep the original case
   when FileSystemCaseSensitive: discard
-  else: toLowerAscii(path)
+  else:
+    for c in mitems(path): c = toLowerAscii(c)
 
 proc fileInfoKnown*(conf: ConfigRef; filename: AbsoluteFile): bool =
   var
diff --git a/compiler/packages.nim b/compiler/packages.nim
index 95c42151b0..ceb3b3ae32 100644
--- a/compiler/packages.nim
+++ b/compiler/packages.nim
@@ -27,7 +27,6 @@ proc getPackage*(conf: ConfigRef; cache: IdentCache; fileIdx: FileIndex): PSym =
   ## * `modulegraphs.getPackage`
   let
     filename = AbsoluteFile toFullPath(conf, fileIdx)
-    name = getIdent(cache, splitFile(filename).name)
     info = newLineInfo(fileIdx, 1, 1)
     pkgName = getPackageName(conf, filename.string)
     pkgIdent = getIdent(cache, pkgName)
diff --git a/compiler/pipelineutils.nim b/compiler/pipelineutils.nim
index b29d513060..eadd48467e 100644
--- a/compiler/pipelineutils.nim
+++ b/compiler/pipelineutils.nim
@@ -1,4 +1,3 @@
-import std/intsets
 import ast, options, lineinfos, pathutils, msgs, modulegraphs, packages
 
 proc skipCodegen*(config: ConfigRef; n: PNode): bool {.inline.} =
diff --git a/compiler/procfind.nim b/compiler/procfind.nim
index c2cc6e71fa..eedf1542cd 100644
--- a/compiler/procfind.nim
+++ b/compiler/procfind.nim
@@ -11,25 +11,10 @@
 # This is needed for proper handling of forward declarations.
 
 import
-  ast, astalgo, msgs, semdata, types, trees, lookups
+  ast, astalgo, msgs, semdata, types, lookups
 
 import std/strutils
 
-proc equalGenericParams(procA, procB: PNode): bool =
-  if procA.len != procB.len: return false
-  for i in 0..<procA.len:
-    if procA[i].kind != nkSym:
-      return false
-    if procB[i].kind != nkSym:
-      return false
-    let a = procA[i].sym
-    let b = procB[i].sym
-    if a.name.id != b.name.id or
-        not sameTypeOrNil(a.typ, b.typ, {ExactTypeDescValues}): return
-    if a.ast != nil and b.ast != nil:
-      if not exprStructuralEquivalent(a.ast, b.ast): return
-  result = true
-
 proc searchForProcAux(c: PContext, scope: PScope, fn: PSym): PSym =
   const flags = {ExactGenericParams, ExactTypeDescValues,
                  ExactConstraints, IgnoreCC}
@@ -59,30 +44,3 @@ proc searchForProc*(c: PContext, scope: PScope, fn: PSym): tuple[proto: PSym, co
     scope = scope.parent
     result.proto = searchForProcAux(c, scope, fn)
     result.comesFromShadowScope = true
-
-when false:
-  proc paramsFitBorrow(child, parent: PNode): bool =
-    result = false
-    if child.len == parent.len:
-      for i in 1..<child.len:
-        var m = child[i].sym
-        var n = parent[i].sym
-        assert((m.kind == skParam) and (n.kind == skParam))
-        if not compareTypes(m.typ, n.typ, dcEqOrDistinctOf): return
-      if not compareTypes(child[0].typ, parent[0].typ,
-                          dcEqOrDistinctOf): return
-      result = true
-
-  proc searchForBorrowProc*(c: PContext, startScope: PScope, fn: PSym): PSym =
-    # Searches for the fn in the symbol table. If the parameter lists are suitable
-    # for borrowing the sym in the symbol table is returned, else nil.
-    var it: TIdentIter = default(TIdentIter)
-    for scope in walkScopes(startScope):
-      result = initIdentIter(it, scope.symbols, fn.Name)
-      while result != nil:
-        # watchout! result must not be the same as fn!
-        if (result.Kind == fn.kind) and (result.id != fn.id):
-          if equalGenericParams(result.ast[genericParamsPos],
-                                fn.ast[genericParamsPos]):
-            if paramsFitBorrow(fn.typ.n, result.typ.n): return
-        result = NextIdentIter(it, scope.symbols)
diff --git a/compiler/renderer.nim b/compiler/renderer.nim
index 1c686ce4b0..0626a7bccc 100644
--- a/compiler/renderer.nim
+++ b/compiler/renderer.nim
@@ -537,10 +537,6 @@ proc putNL(g: var TSrcGen, indent: int) =
   g.lineLen = indent
   g.pendingWhitespace = -1
 
-proc previousNL(g: TSrcGen): bool =
-  result = g.pendingNL >= 0 or (g.tokens.len > 0 and
-                                g.tokens[^1].kind == tkSpaces)
-
 proc putNL(g: var TSrcGen) =
   putNL(g, g.indent)
 
@@ -646,28 +642,6 @@ proc maxLineLength(s: string): int =
       inc(lineLen)
       inc(i)
 
-proc putRawStr(g: var TSrcGen, kind: TokType, s: string) =
-  var i = 0
-  let hi = s.len - 1
-  var str = ""
-  while i <= hi:
-    case s[i]
-    of '\r':
-      put(g, kind, str)
-      str = ""
-      inc(i)
-      if i <= hi and s[i] == '\n': inc(i)
-      optNL(g, 0)
-    of '\n':
-      put(g, kind, str)
-      str = ""
-      inc(i)
-      optNL(g, 0)
-    else:
-      str.add(s[i])
-      inc(i)
-  put(g, kind, str)
-
 proc containsNL(s: string): bool =
   for i in 0..<s.len:
     case s[i]
@@ -1784,7 +1758,6 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
     gsub(g, n, 1)
   of nkInfix:
     if n.len < 3:
-      var i = 0
       put(g, tkOpr, "Too few children for nkInfix")
       return
     let oldLineLen = g.lineLen # we cache this because lineLen gets updated below
@@ -2076,7 +2049,6 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
   of nkPragma:
     if g.inPragma <= 0:
       inc g.inPragma
-      #if not previousNL(g):
       put(g, tkSpaces, Space)
       put(g, tkCurlyDotLe, "{.")
       gcomma(g, n, emptyContext)
diff --git a/compiler/rodutils.nim b/compiler/rodutils.nim
index 5355829c13..1c8dc514fb 100644
--- a/compiler/rodutils.nim
+++ b/compiler/rodutils.nim
@@ -34,14 +34,6 @@ when defined(windows) and defined(bcc):
   #endif
   """.}
 
-proc c_snprintf(s: cstring; n: uint; frmt: cstring): cint {.importc: "snprintf", header: "<stdio.h>", nodecl, varargs.}
-
-
-when not declared(signbit):
-  proc c_signbit(x: SomeFloat): cint {.importc: "signbit", header: "<math.h>".}
-  proc signbit*(x: SomeFloat): bool {.inline.} =
-    result = c_signbit(x) != 0
-
 import std/formatfloat
 
 proc toStrMaxPrecision*(f: BiggestFloat | float32): string =
diff --git a/compiler/sem.nim b/compiler/sem.nim
index a689e2626f..c3c2b82491 100644
--- a/compiler/sem.nim
+++ b/compiler/sem.nim
@@ -332,7 +332,6 @@ proc typeAllowedCheck(c: PContext; info: TLineInfo; typ: PType; kind: TSymKind;
 proc paramsTypeCheck(c: PContext, typ: PType) {.inline.} =
   typeAllowedCheck(c, typ.n.info, typ, skProc)
 
-proc expectMacroOrTemplateCall(c: PContext, n: PNode): PSym
 proc semDirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode
 proc semWhen(c: PContext, n: PNode, semCheck: bool = true): PNode
 proc semTemplateExpr(c: PContext, n: PNode, s: PSym,
diff --git a/compiler/semcall.nim b/compiler/semcall.nim
index 38b88ee7d2..26c459f6d8 100644
--- a/compiler/semcall.nim
+++ b/compiler/semcall.nim
@@ -689,7 +689,7 @@ proc bracketNotFoundError(c: PContext; n: PNode; flags: TExprFlags) =
       baseFilter + {skIterator}
     else: baseFilter
   # this will add the errors:
-  var r = resolveOverloads(c, n, n, filter, flags, errors, true)
+  discard resolveOverloads(c, n, n, filter, flags, errors, true)
   if errors.len == 0:
     localError(c.config, n.info, "could not resolve: " & $n)
   else:
@@ -926,15 +926,6 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
     result.typ = finalCallee.typ.returnType
   updateDefaultParams(c, result)
 
-proc canDeref(n: PNode): bool {.inline.} =
-  result = n.len >= 2 and (let t = n[1].typ;
-    t != nil and t.skipTypes({tyGenericInst, tyAlias, tySink}).kind in {tyPtr, tyRef})
-
-proc tryDeref(n: PNode): PNode =
-  result = newNodeI(nkHiddenDeref, n.info)
-  result.typ = n.typ.skipTypes(abstractInst)[0]
-  result.add n
-
 proc semOverloadedCall(c: PContext, n, nOrig: PNode,
                        filter: TSymKinds, flags: TExprFlags;
                        expectedType: PType = nil): PNode =
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index d4539f7fa2..5361f57724 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -22,7 +22,6 @@ const
   errNamedExprExpected = "named expression expected"
   errNamedExprNotAllowed = "named expression not allowed here"
   errFieldInitTwice = "field initialized twice: '$1'"
-  errUndeclaredFieldX = "undeclared field: '$1'"
 
 proc semTemplateExpr(c: PContext, n: PNode, s: PSym,
                      flags: TExprFlags = {}; expectedType: PType = nil): PNode =
@@ -770,17 +769,6 @@ proc changeType(c: PContext; n: PNode, newType: PType, check: bool) =
 
   n.typ = newType
 
-proc arrayConstrType(c: PContext, n: PNode): PType =
-  var typ = newTypeS(tyArray, c)
-  rawAddSon(typ, nil)     # index type
-  if n.len == 0:
-    rawAddSon(typ, newTypeS(tyEmpty, c)) # needs an empty basetype!
-  else:
-    var t = skipTypes(n[0].typ, {tyGenericInst, tyVar, tyLent, tyOrdinal, tyAlias, tySink})
-    addSonSkipIntLit(typ, t, c.idgen)
-  typ.setIndexType makeRangeType(c, 0, n.len - 1, n.info)
-  result = typ
-
 proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   result = newNodeI(nkBracket, n.info)
   # nkBracket nodes can also be produced by the VM as seq constant nodes
@@ -1339,7 +1327,6 @@ proc lookupInRecordAndBuildCheck(c: PContext, n, r: PNode, field: PIdent,
   else: illFormedAst(n, c.config)
 
 const
-  tyTypeParamsHolders = {tyGenericInst, tyCompositeTypeClass}
   tyDotOpTransparent = {tyVar, tyLent, tyPtr, tyRef, tyOwned, tyAlias, tySink}
 
 proc readTypeParameter(c: PContext, typ: PType,
@@ -2326,24 +2313,6 @@ proc semDeclared(c: PContext, n: PNode, onlyCurrentScope: bool): PNode =
   result.info = n.info
   result.typ = getSysType(c.graph, n.info, tyBool)
 
-proc expectMacroOrTemplateCall(c: PContext, n: PNode): PSym =
-  ## The argument to the proc should be nkCall(...) or similar
-  ## Returns the macro/template symbol
-  if isCallExpr(n):
-    var expandedSym = qualifiedLookUp(c, n[0], {checkUndeclared})
-    if expandedSym == nil:
-      errorUndeclaredIdentifier(c, n.info, n[0].renderTree)
-      return errorSym(c, n[0])
-
-    if expandedSym.kind notin {skMacro, skTemplate}:
-      localError(c.config, n.info, "'$1' is not a macro or template" % expandedSym.name.s)
-      return errorSym(c, n[0])
-
-    result = expandedSym
-  else:
-    localError(c.config, n.info, "'$1' is not a macro or template" % n.renderTree)
-    result = errorSym(c, n)
-
 proc expectString(c: PContext, n: PNode): string =
   var n = semConstExpr(c, n)
   if n.kind in nkStrKinds:
@@ -2358,14 +2327,6 @@ proc newAnonSym(c: PContext; kind: TSymKind, info: TLineInfo): PSym =
 proc semExpandToAst(c: PContext, n: PNode): PNode =
   let macroCall = n[1]
 
-  when false:
-    let expandedSym = expectMacroOrTemplateCall(c, macroCall)
-    if expandedSym.kind == skError: return n
-
-    macroCall[0] = newSymNode(expandedSym, macroCall.info)
-    markUsed(c, n.info, expandedSym)
-    onUse(n.info, expandedSym)
-
   if isCallExpr(macroCall):
     for i in 1..<macroCall.len:
       #if macroCall[0].typ[i].kind != tyUntyped:
@@ -2537,7 +2498,6 @@ proc tryExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
   let oldInStaticContext = c.inStaticContext
   let oldProcCon = c.p
   c.generics = @[]
-  var err: string
   try:
     result = semExpr(c, n, flags)
     if result != nil and efNoSem2Check notin flags:
diff --git a/compiler/semfold.nim b/compiler/semfold.nim
index 371cf539f7..51e5043a39 100644
--- a/compiler/semfold.nim
+++ b/compiler/semfold.nim
@@ -19,7 +19,7 @@ import std/[strutils, math, strtabs]
 #from system/memory import nimCStrLen
 
 when defined(nimPreviewSlimSystem):
-  import std/[assertions, formatfloat]
+  import std/[assertions]
 
 proc errorType*(g: ModuleGraph): PType =
   ## creates a type representing an error state
@@ -121,21 +121,6 @@ proc ordinalValToString*(a: PNode; g: ModuleGraph): string =
   else:
     result = $x
 
-proc isFloatRange(t: PType): bool {.inline.} =
-  result = t.kind == tyRange and t.elementType.kind in {tyFloat..tyFloat128}
-
-proc isIntRange(t: PType): bool {.inline.} =
-  result = t.kind == tyRange and t.elementType.kind in {
-      tyInt..tyInt64, tyUInt8..tyUInt32}
-
-proc pickIntRange(a, b: PType): PType =
-  if isIntRange(a): result = a
-  elif isIntRange(b): result = b
-  else: result = a
-
-proc isIntRangeOrLit(t: PType): bool =
-  result = isIntRange(t) or isIntLit(t)
-
 proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
   # b and c may be nil
   result = nil
@@ -392,11 +377,6 @@ proc rangeCheck(n: PNode, value: Int128; g: ModuleGraph) =
     localError(g.config, n.info, "cannot convert " & $value &
                                     " to " & typeToString(n.typ))
 
-proc floatRangeCheck(n: PNode, value: BiggestFloat; g: ModuleGraph) =
-  if value < firstFloat(n.typ) or value > lastFloat(n.typ):
-    localError(g.config, n.info, "cannot convert " & $value &
-                                    " to " & typeToString(n.typ))
-
 proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): PNode =
   let dstTyp = skipTypes(n.typ, abstractRange - {tyTypeDesc})
   let srcTyp = skipTypes(a.typ, abstractRange - {tyTypeDesc})
diff --git a/compiler/semgnrc.nim b/compiler/semgnrc.nim
index 91a834078d..da9b1c187c 100644
--- a/compiler/semgnrc.nim
+++ b/compiler/semgnrc.nim
@@ -233,7 +233,7 @@ proc fuzzyLookup(c: PContext, n: PNode, flags: TSemGenericFlags,
         if s.kind == skType: # don't put types in sym choice
           var ambig = false
           if candidates.len > 1:
-            let s2 = searchInScopes(c, ident, ambig)
+            discard searchInScopes(c, ident, ambig)
           result = newDot(result, semGenericStmtSymbol(c, n, s, ctx, flags,
             isAmbiguous = ambig, fromDotExpr = true))
         else:
diff --git a/compiler/semobjconstr.nim b/compiler/semobjconstr.nim
index 769f88b6f2..bb6dbe4144 100644
--- a/compiler/semobjconstr.nim
+++ b/compiler/semobjconstr.nim
@@ -440,7 +440,7 @@ proc initConstrContext(t: PType, initExpr: PNode): ObjConstrContext =
 proc computeRequiresInit(c: PContext, t: PType): bool =
   assert t.kind == tyObject
   var constrCtx = initConstrContext(t, newNode(nkObjConstr))
-  let initResult = semConstructTypeAux(c, constrCtx, {efWantNoDefaults})
+  discard semConstructTypeAux(c, constrCtx, {efWantNoDefaults})
   constrCtx.missingFields.len > 0
 
 proc defaultConstructionError(c: PContext, t: PType, info: TLineInfo) =
@@ -450,7 +450,7 @@ proc defaultConstructionError(c: PContext, t: PType, info: TLineInfo) =
     assert objType != nil
   if objType.kind == tyObject:
     var constrCtx = initConstrContext(objType, newNodeI(nkObjConstr, info))
-    let initResult = semConstructTypeAux(c, constrCtx, {efIgnoreDefaults})
+    discard semConstructTypeAux(c, constrCtx, {efIgnoreDefaults})
     if constrCtx.missingFields.len > 0:
       localError(c.config, info,
         "The $1 type doesn't have a default value. The following fields must be initialized: $2." % [typeToString(t), listSymbolNames(constrCtx.missingFields)])
diff --git a/compiler/sempass2.nim b/compiler/sempass2.nim
index 2d1a42cd86..1bc5bac628 100644
--- a/compiler/sempass2.nim
+++ b/compiler/sempass2.nim
@@ -1006,7 +1006,6 @@ proc trackIf(tracked: PEffects, n: PNode) =
 
 proc trackBlock(tracked: PEffects, n: PNode; typ: PType) =
   if n.kind in {nkStmtList, nkStmtListExpr}:
-    let myBlock = tracked.currentBlock
     var oldState = -1
     for i in 0..<n.len:
       if hasSubnodeWith(n[i], nkBreakStmt):
@@ -1029,11 +1028,6 @@ proc trackBlock(tracked: PEffects, n: PNode; typ: PType) =
   else:
     track(tracked, n)
 
-proc cstringCheck(tracked: PEffects; n: PNode) =
-  if n[0].typ.kind == tyCstring and (let a = skipConv(n[1]);
-      a.typ.kind == tyString and a.kind notin {nkStrLit..nkTripleStrLit}):
-    message(tracked.config, n.info, warnUnsafeCode, renderTree(n))
-
 proc patchResult(c: PEffects; n: PNode) =
   if n.kind == nkSym and n.sym.kind == skResult:
     let fn = c.owner
@@ -1511,7 +1505,6 @@ proc track(tracked: PEffects, n: PNode) =
     dec tracked.leftPartOfAsgn
     addAsgnFact(tracked.guards, n[0], n[1])
     notNilCheck(tracked, n[1], n[0].typ)
-    when false: cstringCheck(tracked, n)
     if tracked.owner.kind != skMacro and n[0].typ.kind notin {tyOpenArray, tyVarargs}:
       createTypeBoundOps(tracked, n[0].typ, n.info)
     if n[0].kind != nkSym or not isLocalSym(tracked, n[0].sym):
@@ -2001,7 +1994,6 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
     patchResult(t, ensuresSpec)
     effects[ensuresEffects] = ensuresSpec
 
-  var mutationInfo = MutationInfo()
   if views in c.features:
     var partitions = computeGraphPartitions(s, body, g, {borrowChecking})
     checkBorrowedLocations(partitions, body, g.config)
diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index cee96cd9d9..efbd6b574b 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -17,18 +17,14 @@ const
   errInvalidControlFlowX = "invalid control flow: $1"
   errSelectorMustBeOfCertainTypes = "selector must be of an ordinal type, float or string"
   errExprCannotBeRaised = "only a 'ref object' can be raised"
-  errBreakOnlyInLoop = "'break' only allowed in loop construct"
   errExceptionAlreadyHandled = "exception already handled"
   errYieldNotAllowedHere = "'yield' only allowed in an iterator"
-  errYieldNotAllowedInTryStmt = "'yield' cannot be used within 'try' in a non-inlined iterator"
-  errInvalidNumberOfYieldExpr = "invalid number of 'yield' expressions"
   errCannotReturnExpr = "current routine cannot return an expression"
   errGenericLambdaNotAllowed = "A nested proc can have generic parameters only when " &
     "it is used as an operand to another routine and the types " &
     "of the generic paramers can be inferred from the expected signature."
   errCannotInferTypeOfTheLiteral = "cannot infer the type of the $1"
   errCannotInferReturnType = "cannot infer the return type of '$1'"
-  errCannotInferStaticParam = "cannot infer the value of the static param '$1'"
   errProcHasNoConcreteType = "'$1' doesn't have a concrete type, due to unspecified generic parameters."
   errLetNeedsInit = "'let' symbol requires an initialization"
   errThreadvarCannotInit = "a thread var cannot be initialized explicitly; this would only run for the main thread"
@@ -545,7 +541,6 @@ proc semUsing(c: PContext; n: PNode): PNode =
         strTableIncl(c.signatures, v)
     else:
       localError(c.config, a.info, "'using' section must have a type")
-    var def: PNode
     if a[^1].kind != nkEmpty:
       localError(c.config, a.info, "'using' sections cannot contain assignments")
 
diff --git a/compiler/semtempl.nim b/compiler/semtempl.nim
index 8d2fe1823f..a2512b5cc0 100644
--- a/compiler/semtempl.nim
+++ b/compiler/semtempl.nim
@@ -581,7 +581,7 @@ proc semTemplBody(c: var TemplCtx, n: PNode): PNode =
         result.add newIdentNode(getIdent(c.c.cache, "[]="), n.info)
         for i in 0..<a.len: result.add(a[i])
         result.add(b)
-      let a0 = semTemplBody(c, a[0])
+      discard semTemplBody(c, a[0])
       result = semTemplBodySons(c, result)
     of nkCurlyExpr:
       if a.typ == nil:
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index 033d38e518..9cfa729c32 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -19,13 +19,11 @@ const
   errOverflowInEnumX = "The enum '$1' exceeds its maximum value ($2)"
   errOrdinalTypeExpected = "ordinal type expected; given: $1"
   errSetTooBig = "set is too large; use `std/sets` for ordinal types with more than 2^16 elements"
-  errBaseTypeMustBeOrdinal = "base type of a set must be an ordinal"
   errInheritanceOnlyWithNonFinalObjects = "inheritance only works with non-final objects"
   errXExpectsOneTypeParam = "'$1' expects one type parameter"
   errArrayExpectsTwoTypeParams = "array expects two type parameters"
   errInvalidVisibilityX = "invalid visibility: '$1'"
   errXCannotBeAssignedTo = "'$1' cannot be assigned to"
-  errIteratorNotAllowed = "iterators can only be defined at the module's top level"
   errXNeedsReturnType = "$1 needs a return type"
   errNoReturnTypeDeclared = "no return type declared"
   errTIsNotAConcreteType = "'$1' is not a concrete type"
@@ -1966,7 +1964,6 @@ proc semTypeClass(c: PContext, n: PNode, prev: PType): PType =
     return result
 
   let
-    pragmas = n[1]
     inherited = n[2]
 
   var owner = getCurrOwner(c)
diff --git a/compiler/semtypinst.nim b/compiler/semtypinst.nim
index 4c1a1b4cb3..861a96f513 100644
--- a/compiler/semtypinst.nim
+++ b/compiler/semtypinst.nim
@@ -180,35 +180,6 @@ proc prepareNode*(cl: var TReplTypeVars, n: PNode): PNode =
     for i in 0..<n.safeLen:
       result.add(prepareNode(cl, n[i]))
 
-proc isTypeParam(n: PNode): bool =
-  # XXX: generic params should use skGenericParam instead of skType
-  return n.kind == nkSym and
-         (n.sym.kind == skGenericParam or
-           (n.sym.kind == skType and sfFromGeneric in n.sym.flags))
-
-when false: # old workaround
-  proc reResolveCallsWithTypedescParams(cl: var TReplTypeVars, n: PNode): PNode =
-    # This is needed for tuninstantiatedgenericcalls
-    # It's possible that a generic param will be used in a proc call to a
-    # typedesc accepting proc. After generic param substitution, such procs
-    # should be optionally instantiated with the correct type. In order to
-    # perform this instantiation, we need to re-run the generateInstance path
-    # in the compiler, but it's quite complicated to do so at the moment so we
-    # resort to a mild hack; the head symbol of the call is temporary reset and
-    # overload resolution is executed again (which may trigger generateInstance).
-    if n.kind in nkCallKinds and sfFromGeneric in n[0].sym.flags:
-      var needsFixing = false
-      for i in 1..<n.safeLen:
-        if isTypeParam(n[i]): needsFixing = true
-      if needsFixing:
-        n[0] = newSymNode(n[0].sym.owner)
-        return cl.c.semOverloadedCall(cl.c, n, n, {skProc, skFunc}, {})
-
-    for i in 0..<n.safeLen:
-      n[i] = reResolveCallsWithTypedescParams(cl, n[i])
-
-    return n
-
 proc replaceObjBranches(cl: TReplTypeVars, n: PNode): PNode =
   result = n
   case n.kind
diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim
index 9238f4e7d4..139b2a0a7d 100644
--- a/compiler/sigmatch.nim
+++ b/compiler/sigmatch.nim
@@ -182,7 +182,6 @@ proc matchGenericParams*(m: var TCandidate, binding: PNode, callee: PSym) =
   ## state is set to `csMatch` if all generic params match, `csEmpty` if
   ## implicit generic parameters are missing (matches but cannot instantiate),
   ## `csNoMatch` if a constraint fails or param count doesn't match
-  let c = m.c
   let typeParams = callee.ast[genericParamsPos]
   let paramCount = typeParams.len
   let bindingCount = binding.len-1
@@ -707,8 +706,6 @@ proc recordRel(c: var TCandidate, f, a: PType, flags: TTypeRelFlags): TTypeRelat
     result = isEqual
   elif sameTupleLengths(a, f):
     result = isEqual
-    let firstField = if f.kind == tyTuple: 0
-                     else: 1
     for _, ff, aa in tupleTypePairs(f, a):
       var m = typeRel(c, ff, aa, flags)
       if m < isSubtype: return isNone
diff --git a/compiler/sourcemap.nim b/compiler/sourcemap.nim
index 1395168cd1..441f0694be 100644
--- a/compiler/sourcemap.nim
+++ b/compiler/sourcemap.nim
@@ -97,9 +97,7 @@ iterator tokenize*(line: string): (int, string) =
   ## normal JS code. This allows us to map mangled names back to Nim names.
   ## Yields (column, name). Doesn't yield anything but identifiers.
   ## See mangleName in compiler/jsgen.nim for how name mangling is done
-  var
-    col = 0
-    token = ""
+  var col = 0
   while col < line.len:
     var
       token: string = ""
@@ -128,7 +126,6 @@ func parse*(source: string): SourceInfo =
   ## So it can convert those into a series of mappings
   result = default(SourceInfo)
   var
-    skipFirstLine = true
     currColumn = 0
     currLine = 0
     currFile = ""
diff --git a/compiler/spawn.nim b/compiler/spawn.nim
index cbadc807c6..a49565cf46 100644
--- a/compiler/spawn.nim
+++ b/compiler/spawn.nim
@@ -11,7 +11,6 @@
 
 import ast, types, idents, magicsys, msgs, options, modulegraphs,
   lowerings, liftdestructors, renderer, trees
-from trees import getMagic, getRoot
 
 proc callProc(a: PNode): PNode =
   result = newNodeI(nkCall, a.info)
diff --git a/compiler/types.nim b/compiler/types.nim
index b6da7d4c12..fe4334fc34 100644
--- a/compiler/types.nim
+++ b/compiler/types.nim
@@ -11,12 +11,12 @@
 
 import
   ast, astalgo, trees, msgs, platform, renderer, options,
-  lineinfos, int128, modulegraphs, astmsgs, wordrecg
+  lineinfos, int128, modulegraphs, astmsgs
 
 import std/[intsets, strutils]
 
 when defined(nimPreviewSlimSystem):
-  import std/[assertions, formatfloat]
+  import std/[assertions]
 
 export isResolvedUserTypeClass, TPreferedDesc, typeToString
 
@@ -869,11 +869,6 @@ proc sameObjectTree(a, b: PNode, c: var TSameTypeClosure): bool =
   else:
     result = false
 
-proc sameObjectStructures(a, b: PType, c: var TSameTypeClosure): bool =
-  if not sameTypeOrNilAux(a.baseClass, b.baseClass, c): return false
-  if not sameObjectTree(a.n, b.n, c): return false
-  result = true
-
 proc sameChildrenAux(a, b: PType, c: var TSameTypeClosure): bool =
   if not sameTupleLengths(a, b): return false
   # XXX This is not tuple specific.
diff --git a/compiler/vm.nim b/compiler/vm.nim
index 0d9ab99b2e..8149ed1b44 100644
--- a/compiler/vm.nim
+++ b/compiler/vm.nim
@@ -158,23 +158,6 @@ proc derefPtrToReg(address: BiggestInt, typ: PType, r: var TFullReg, isAssign: b
   of tyFloat64: fun(floatVal, float64, rkFloat)
   else: return false
 
-proc createStrKeepNode(x: var TFullReg; keepNode=true) =
-  if x.node.isNil or not keepNode:
-    x.node = newNode(nkStrLit)
-  elif x.node.kind == nkNilLit and keepNode:
-    when defined(useNodeIds):
-      let id = x.node.id
-    x.node[] = TNode(kind: nkStrLit)
-    when defined(useNodeIds):
-      x.node.id = id
-  elif x.node.kind notin {nkStrLit..nkTripleStrLit} or
-      nfAllConst in x.node.flags:
-    # XXX this is hacky; tests/txmlgen triggers it:
-    x.node = newNode(nkStrLit)
-    # It not only hackey, it is also wrong for tgentemplate. The primary
-    # cause of bugs like these is that the VM does not properly distinguish
-    # between variable definitions (var foo = e) and variable updates (foo = e).
-
 include vmhooks
 
 template createStr(x) =
@@ -1758,7 +1741,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       stackTrace(c, tos, pc, msg2)
     of opcSetLenStr:
       decodeB(rkNode)
-      #createStrKeepNode regs[ra]
       regs[ra].node.strVal.setLen(regs[rb].intVal.int)
     of opcOf:
       decodeBC(rkInt)
@@ -2203,7 +2185,6 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       inc pc
       let desttyp = c.types[c.code[pc].regBx - wordExcess]
       inc pc
-      let srctyp = c.types[c.code[pc].regBx - wordExcess]
 
       when hasFFI:
         let dest = fficast(c.config, regs[rb].node, desttyp)
diff --git a/compiler/vmgen.nim b/compiler/vmgen.nim
index 3848284bf5..174f163d8b 100644
--- a/compiler/vmgen.nim
+++ b/compiler/vmgen.nim
@@ -874,11 +874,6 @@ proc genBinaryStmtVar(c: PCtx; n: PNode; opc: TOpcode) =
   c.freeTemp(tmp)
   c.freeTemp(dest)
 
-proc genUnaryStmt(c: PCtx; n: PNode; opc: TOpcode) =
-  let tmp = c.genx(n[1])
-  c.gABC(n, opc, tmp, 0, 0)
-  c.freeTemp(tmp)
-
 proc genVarargsABC(c: PCtx; n: PNode; dest: var TDest; opc: TOpcode) =
   if dest < 0: dest = getTemp(c, n.typ)
   var x = c.getTempRange(n.len-1, slotTempStr)
diff --git a/compiler/vmops.nim b/compiler/vmops.nim
index b526916d3c..96a720e182 100644
--- a/compiler/vmops.nim
+++ b/compiler/vmops.nim
@@ -48,9 +48,6 @@ import vmconv, vmmarshal
 template mathop(op) {.dirty.} =
   registerCallback(c, "stdlib.math." & astToStr(op), `op Wrapper`)
 
-template osop(op) {.dirty.} =
-  registerCallback(c, "stdlib.os." & astToStr(op), `op Wrapper`)
-
 template oscommonop(op) {.dirty.} =
   registerCallback(c, "stdlib.oscommon." & astToStr(op), `op Wrapper`)
 
diff --git a/compiler/vmprofiler.nim b/compiler/vmprofiler.nim
index 38d9f1532f..cb36de134b 100644
--- a/compiler/vmprofiler.nim
+++ b/compiler/vmprofiler.nim
@@ -30,7 +30,6 @@ proc dump*(conf: ConfigRef, pd: ProfileData): string =
   var data = pd.data
   result = "\nprof:     µs    #instr  location"
   for i in 0..<32:
-    var tMax: float
     var infoMax: ProfileInfo = default(ProfileInfo)
     var flMax: TLineInfo = default(TLineInfo)
     for fl, info in data:
diff --git a/compiler/vtables.nim b/compiler/vtables.nim
index 5b05daa868..e17125c479 100644
--- a/compiler/vtables.nim
+++ b/compiler/vtables.nim
@@ -16,7 +16,6 @@ proc dispatch(x: Base, params: ...) =
   var disp = newNodeI(nkIfStmt, base.info)
 
   let nimGetVTableSym = getCompilerProc(g, "nimGetVTable")
-  let ptrPNimType = nimGetVTableSym.typ.n[1].sym.typ
 
   var nTyp = base.typ.n[1].sym.typ
   var dispatchObject = newSymNode(base.typ.n[1].sym)