'nil' as a statement is deprecated, use an empty 'discard' instead

54 files changed, 170 insertions, 170 deletions

diff --git a/compiler/aliases.nim b/compiler/aliases.nim
index 5be7b5f12..a26b94303 100644
--- a/compiler/aliases.nim
+++ b/compiler/aliases.nim
@@ -54,7 +54,7 @@ proc isPartOfAux(a, b: PType, marker: var TIntSet): TAnalysisResult =
     for i in countup(0, sonsLen(a) - 1): 
       result = isPartOfAux(a.sons[i], b, marker)
       if result == arYes: return 
-  else: nil
+  else: discard
 
 proc isPartOf(a, b: PType): TAnalysisResult = 
   ## checks iff 'a' can be part of 'b'. Iterates over VALUE types!
@@ -140,7 +140,7 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
       result = isPartOf(a[1], b[1])
     of nkObjUpConv, nkObjDownConv, nkCheckedFieldExpr:
       result = isPartOf(a[0], b[0])
-    else: nil
+    else: discard
     # Calls return a new location, so a default of ``arNo`` is fine.
   else:
     # go down recursively; this is quite demanding:
@@ -177,6 +177,6 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
         if isPartOf(a.typ, b.typ) != arNo:
           result = isPartOf(a[0], b)
           if result == arNo: result = arMaybe
-      else: nil
-    else: nil
+      else: discard
+    else: discard
 
diff --git a/compiler/ast.nim b/compiler/ast.nim
index 1d356b6d8..0e351a31a 100644
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -1257,7 +1257,7 @@ proc propagateToOwner*(owner, elem: PType) =
       owner.flags.incl tfNeedsInit
   
   if tfNeedsInit in elem.flags:
-    if owner.kind in HaveTheirOwnEmpty: nil
+    if owner.kind in HaveTheirOwnEmpty: discard
     else: owner.flags.incl tfNeedsInit
     
   if tfShared in elem.flags:
diff --git a/compiler/ccgcalls.nim b/compiler/ccgcalls.nim
index ec1250155..1c6eea621 100644
--- a/compiler/ccgcalls.nim
+++ b/compiler/ccgcalls.nim
@@ -73,7 +73,7 @@ proc isInCurrentFrame(p: BProc, n: PNode): bool =
     result = false
   of nkObjUpConv, nkObjDownConv, nkCheckedFieldExpr:
     result = isInCurrentFrame(p, n.sons[0])
-  else: nil
+  else: discard
 
 proc openArrayLoc(p: BProc, n: PNode): PRope =
   var a: TLoc
diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index 22a00cf29..9554c6b55 100644
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -202,7 +202,7 @@ proc asgnComplexity(n: PNode): int =
     of nkRecList:
       for t in items(n):
         result += asgnComplexity(t)
-    else: nil
+    else: discard
 
 proc optAsgnLoc(a: TLoc, t: PType, field: PRope): TLoc =
   result.k = locField
@@ -228,7 +228,7 @@ proc genOptAsgnObject(p: BProc, dest, src: TLoc, flags: TAssignmentFlags,
                      optAsgnLoc(src, field.typ, field.loc.r), flags)
   of nkRecList:
     for child in items(t): genOptAsgnObject(p, dest, src, flags, child)
-  else: nil
+  else: discard
 
 proc genGenericAsgn(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
   # Consider: 
@@ -1901,7 +1901,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
   of nkClosure: genClosure(p, n, d)
   of nkMetaNode: expr(p, n.sons[0], d)
 
-  of nkEmpty:  nil
+  of nkEmpty: discard
   of nkWhileStmt: genWhileStmt(p, n)
   of nkVarSection, nkLetSection: genVarStmt(p, n)
   of nkConstSection: genConstStmt(p, n)
@@ -1931,7 +1931,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
   of nkCommentStmt, nkIteratorDef, nkIncludeStmt, 
      nkImportStmt, nkImportExceptStmt, nkExportStmt, nkExportExceptStmt, 
      nkFromStmt, nkTemplateDef, nkMacroDef: 
-    nil
+    discard
   of nkPragma: genPragma(p, n)
   of nkProcDef, nkMethodDef, nkConverterDef: 
     if (n.sons[genericParamsPos].kind == nkEmpty):
diff --git a/compiler/ccgmerge.nim b/compiler/ccgmerge.nim
index 514b77b73..5b04f1358 100644
--- a/compiler/ccgmerge.nim
+++ b/compiler/ccgmerge.nim
@@ -285,7 +285,7 @@ proc readMergeSections(cfilename: string, m: var TMergeSections) =
   withCFile(cfilename):
     readKey(L, k)
     if k == "NIM_merge_INFO":   
-      nil
+      discard
     elif ^L.bufpos == '*' and ^(L.bufpos+1) == '/':
       inc(L.bufpos, 2)
       # read back into section
diff --git a/compiler/ccgtrav.nim b/compiler/ccgtrav.nim
index ecf1eb152..26f474659 100644
--- a/compiler/ccgtrav.nim
+++ b/compiler/ccgtrav.nim
@@ -83,7 +83,7 @@ proc genTraverseProc(c: var TTraversalClosure, accessor: PRope, typ: PType) =
     if typ.callConv == ccClosure:
       lineCg(p, cpsStmts, c.visitorFrmt, rfmt(nil, "$1.ClEnv", accessor))
   else:
-    nil
+    discard
 
 proc genTraverseProcSeq(c: var TTraversalClosure, accessor: PRope, typ: PType) =
   var p = c.p
diff --git a/compiler/ccgtypes.nim b/compiler/ccgtypes.nim
index 79f10b981..c92c15fa9 100644
--- a/compiler/ccgtypes.nim
+++ b/compiler/ccgtypes.nim
@@ -25,7 +25,7 @@ proc mangleField(name: string): string =
     of 'A'..'Z': 
       add(result, chr(ord(name[i]) - ord('A') + ord('a')))
     of '_': 
-      nil
+      discard
     of 'a'..'z', '0'..'9': 
       add(result, name[i])
     else: 
@@ -48,7 +48,7 @@ proc mangle(name: string): string =
     of 'A'..'Z': 
       add(result, chr(ord(name[i]) - ord('A') + ord('a')))
     of '_': 
-      nil
+      discard
     of 'a'..'z', '0'..'9': 
       add(result, name[i])
     else: 
diff --git a/compiler/cgen.nim b/compiler/cgen.nim
index c7de1091b..0e6e48399 100644
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -319,7 +319,7 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: TLoc,
                    takeAddr: bool) =
   case analyseObjectWithTypeField(t)
   of frNone:
-    nil
+    discard
   of frHeader:
     var r = rdLoc(a)
     if not takeAddr: r = ropef("(*$1)", [r])
@@ -832,7 +832,7 @@ proc genProcNoForward(m: BModule, prc: PSym) =
     discard cgsym(m, prc.name.s)
     return  
   genProcPrototype(m, prc)
-  if lfNoDecl in prc.loc.flags: nil
+  if lfNoDecl in prc.loc.flags: discard
   elif prc.typ.callConv == ccInline:
     # We add inline procs to the calling module to enable C based inlining.
     # This also means that a check with ``q.declaredThings`` is wrong, we need
diff --git a/compiler/cgmeth.nim b/compiler/cgmeth.nim
index 9613eb525..1c5ce7a21 100644
--- a/compiler/cgmeth.nim
+++ b/compiler/cgmeth.nim
@@ -66,7 +66,7 @@ proc sameMethodBucket(a, b: PSym): bool =
     if sameType(aa, bb) or
         (aa.kind == tyObject) and (bb.kind == tyObject) and
         (inheritanceDiff(bb, aa) < 0):
-      nil
+      discard
     else:
       return
   result = true
diff --git a/compiler/depends.nim b/compiler/depends.nim
index 5b02275c6..a43eaf844 100644
--- a/compiler/depends.nim
+++ b/compiler/depends.nim
@@ -39,7 +39,7 @@ proc addDotDependency(c: PPassContext, n: PNode): PNode =
   of nkStmtList, nkBlockStmt, nkStmtListExpr, nkBlockExpr: 
     for i in countup(0, sonsLen(n) - 1): discard addDotDependency(c, n.sons[i])
   else: 
-    nil
+    discard
 
 proc generateDot(project: string) = 
   writeRope(ropef("digraph $1 {$n$2}$n", [
diff --git a/compiler/docgen2.nim b/compiler/docgen2.nim
index d48f53d15..d76be8e3c 100644
--- a/compiler/docgen2.nim
+++ b/compiler/docgen2.nim
@@ -27,7 +27,7 @@ proc close(p: PPassContext, n: PNode): PNode =
     try:
       generateIndex(g.doc)
     except EIO:
-      nil
+      discard
 
 proc processNode(c: PPassContext, n: PNode): PNode = 
   result = n
@@ -46,4 +46,4 @@ proc myOpen(module: PSym): PPassContext =
 const docgen2Pass* = makePass(open = myOpen, process = processNode, close = close)
 
 proc finishDoc2Pass*(project: string) = 
-  nil
+  discard
diff --git a/compiler/filter_tmpl.nim b/compiler/filter_tmpl.nim
index 806754122..0014e9c78 100644
--- a/compiler/filter_tmpl.nim
+++ b/compiler/filter_tmpl.nim
@@ -55,7 +55,7 @@ proc scanPar(p: var TTmplParser, d: int) =
     of ']': dec(p.bracket)
     of '{': inc(p.curly)
     of '}': dec(p.curly)
-    else: nil
+    else: discard
     inc(i)
 
 proc withInExpr(p: TTmplParser): bool {.inline.} = 
diff --git a/compiler/guards.nim b/compiler/guards.nim
index 3d27c85c9..607bb074a 100644
--- a/compiler/guards.nim
+++ b/compiler/guards.nim
@@ -439,7 +439,7 @@ proc impliesLe(fact, x, c: PNode): TImplication =
         if leValue(c, fact.sons[1].pred): result = impNo
 
   of mNot, mOr, mAnd: internalError(x.info, "impliesLe")
-  else: nil
+  else: discard
 
 proc impliesLt(fact, x, c: PNode): TImplication =
   # x < 3  same as x <= 2:
diff --git a/compiler/hlo.nim b/compiler/hlo.nim
index e3f80ad36..7982d4aa1 100644
--- a/compiler/hlo.nim
+++ b/compiler/hlo.nim
@@ -81,7 +81,7 @@ proc hlo(c: PContext, n: PNode): PNode =
     else:
       # perform type checking, so that the replacement still fits:
       if isEmptyType(n.typ) and isEmptyType(result.typ):
-        nil
+        discard
       else:
         result = fitNode(c, n.typ, result)
       # optimization has been applied so check again:
diff --git a/compiler/jsgen.nim b/compiler/jsgen.nim
index dd06b0235..82c45059c 100644
--- a/compiler/jsgen.nim
+++ b/compiler/jsgen.nim
@@ -143,7 +143,7 @@ proc mangle(name: string): string =
     of 'A'..'Z': 
       add(result, chr(ord(name[i]) - ord('A') + ord('a')))
     of '_': 
-      nil
+      discard
     of 'a'..'z', '0'..'9': 
       add(result, name[i])
     else: add(result, 'X' & toHex(ord(name[i]), 2))
@@ -996,10 +996,10 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
     r.res = s.loc.r
     if lfNoDecl in s.loc.flags or s.magic != mNone or
        {sfImportc, sfInfixCall} * s.flags != {}:
-      nil
+      discard
     elif s.kind == skMethod and s.getBody.kind == nkEmpty:
       # we cannot produce code for the dispatcher yet:
-      nil
+      discard
     elif sfForward in s.flags:
       p.g.forwarded.add(s)
     elif not p.g.generatedSyms.containsOrIncl(s.id):
@@ -1336,10 +1336,10 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
     else:
       unaryExpr(p, n, r, "", "($1.length-1)")
   of mInc:
-    if not (optOverflowCheck in p.options): binaryExpr(p, n, r, "", "$1 += $2")
+    if optOverflowCheck notin p.options: binaryExpr(p, n, r, "", "$1 += $2")
     else: binaryExpr(p, n, r, "addInt", "$1 = addInt($1, $2)")
   of ast.mDec:
-    if not (optOverflowCheck in p.options): binaryExpr(p, n, r, "", "$1 -= $2")
+    if optOverflowCheck notin p.options: binaryExpr(p, n, r, "", "$1 -= $2")
     else: binaryExpr(p, n, r, "subInt", "$1 = subInt($1, $2)")
   of mSetLengthStr: binaryExpr(p, n, r, "", "$1.length = ($2)-1")
   of mSetLengthSeq: binaryExpr(p, n, r, "", "$1.length = $2")
@@ -1544,7 +1544,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
     r.res = toRope(n.intVal)
   of nkNilLit:
     if isEmptyType(n.typ):
-      nil
+      discard
     elif mapType(n.typ) == etyBaseIndex:
       r.typ = etyBaseIndex
       r.address = toRope"null" | toRope"nil"
@@ -1592,12 +1592,12 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
   of nkChckRange: genRangeChck(p, n, r, "chckRange")
   of nkStringToCString: convStrToCStr(p, n, r)
   of nkCStringToString: convCStrToStr(p, n, r)
-  of nkEmpty: nil
+  of nkEmpty: discard
   of nkLambdaKinds: 
     let s = n.sons[namePos].sym
     discard mangleName(s)
     r.res = s.loc.r
-    if lfNoDecl in s.loc.flags or s.magic != mNone: nil
+    if lfNoDecl in s.loc.flags or s.magic != mNone: discard
     elif not p.g.generatedSyms.containsOrIncl(s.id):
       app(p.locals, genProc(p, s))
   of nkMetaNode: gen(p, n.sons[0], r)
@@ -1614,7 +1614,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
   of nkIfStmt, nkIfExpr: genIf(p, n, r)
   of nkWhileStmt: genWhileStmt(p, n)
   of nkVarSection, nkLetSection: genVarStmt(p, n)
-  of nkConstSection: nil
+  of nkConstSection: discard
   of nkForStmt, nkParForStmt: 
     internalError(n.info, "for statement not eliminated")
   of nkCaseStmt: 
@@ -1633,7 +1633,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
   of nkRaiseStmt: genRaiseStmt(p, n)
   of nkTypeSection, nkCommentStmt, nkIteratorDef, nkIncludeStmt, 
      nkImportStmt, nkImportExceptStmt, nkExportStmt, nkExportExceptStmt, 
-     nkFromStmt, nkTemplateDef, nkMacroDef, nkPragma: nil
+     nkFromStmt, nkTemplateDef, nkMacroDef, nkPragma: discard
   of nkProcDef, nkMethodDef, nkConverterDef:
     var s = n.sons[namePos].sym
     if {sfExportc, sfCompilerProc} * s.flags == {sfExportc}:
diff --git a/compiler/lambdalifting.nim b/compiler/lambdalifting.nim
index 9e42210c0..ed92fefb4 100644
--- a/compiler/lambdalifting.nim
+++ b/compiler/lambdalifting.nim
@@ -1,7 +1,7 @@
 #
 #
 #           The Nimrod Compiler
-#        (c) Copyright 2013 Andreas Rumpf
+#        (c) Copyright 2014 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.
@@ -275,7 +275,7 @@ proc captureVar(o: POuterContext, i: PInnerContext, local: PSym,
   addCapturedVar(it, local)
   if it == e:
     # common case: local directly in current environment:
-    nil
+    discard
   else:
     # it's in some upper environment:
     access = indirectAccess(access, addDep(e, it, i.fn), info)
@@ -314,7 +314,7 @@ proc gatherVars(o: POuterContext, i: PInnerContext, n: PNode) =
       if o.currentEnv != env:
         discard addDep(o.currentEnv, env, i.fn)
         internalError(n.info, "too complex environment handling required")
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
+  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: discard
   else:
     for k in countup(0, sonsLen(n) - 1): 
       gatherVars(o, i, n.sons[k])
@@ -351,7 +351,7 @@ proc makeClosure(prc, env: PSym, info: TLineInfo): PNode =
 
 proc transformInnerProc(o: POuterContext, i: PInnerContext, n: PNode): PNode =
   case n.kind
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
+  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: discard
   of nkSym:
     let s = n.sym
     if s == i.fn: 
@@ -371,7 +371,7 @@ proc transformInnerProc(o: POuterContext, i: PInnerContext, n: PNode): PNode =
   of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef,
      nkIteratorDef:
     # don't recurse here:
-    nil
+    discard
   else:
     for j in countup(0, sonsLen(n) - 1):
       let x = transformInnerProc(o, i, n.sons[j])
@@ -386,7 +386,7 @@ proc searchForInnerProcs(o: POuterContext, n: PNode) =
   if n == nil: return
   case n.kind
   of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: 
-    nil
+    discard
   of nkSym:
     if isInnerProc(n.sym, o.fn) and not containsOrIncl(o.processed, n.sym.id):
       var inner = newInnerContext(n.sym)
@@ -422,7 +422,7 @@ proc searchForInnerProcs(o: POuterContext, n: PNode) =
     # counts, not the block where it is captured!
     for i in countup(0, sonsLen(n) - 1):
       var it = n.sons[i]
-      if it.kind == nkCommentStmt: nil
+      if it.kind == nkCommentStmt: discard
       elif it.kind == nkIdentDefs:
         var L = sonsLen(it)
         if it.sons[0].kind != nkSym: internalError(it.info, "transformOuter")
@@ -441,7 +441,7 @@ proc searchForInnerProcs(o: POuterContext, n: PNode) =
      nkIteratorDef:
     # don't recurse here:
     # XXX recurse here and setup 'up' pointers
-    nil
+    discard
   else:
     for i in countup(0, sonsLen(n) - 1):
       searchForInnerProcs(o, n.sons[i])
@@ -500,7 +500,7 @@ proc generateClosureCreation(o: POuterContext, scope: PEnv): PNode =
 proc transformOuterProc(o: POuterContext, n: PNode): PNode =
   if n == nil: return nil
   case n.kind
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
+  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: discard
   of nkSym:
     var local = n.sym
     var closure = PEnv(idTableGet(o.lambdasToEnv, local))
@@ -540,7 +540,7 @@ proc transformOuterProc(o: POuterContext, n: PNode): PNode =
   of nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef, nkTemplateDef, 
      nkIteratorDef: 
     # don't recurse here:
-    nil
+    discard
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
     let x = transformOuterProc(o, n.sons[1])
     if x != nil: n.sons[1] = x
@@ -625,7 +625,7 @@ proc transfIterBody(c: var TIterContext, n: PNode): PNode =
     if interestingIterVar(s) and c.iter.id == s.owner.id:
       if not containsOrIncl(c.capturedVars, s.id): addField(c.tup, s)
       result = indirectAccess(newSymNode(c.closureParam), s, n.info)
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: nil
+  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit: discard
   of nkYieldStmt:
     inc c.state.typ.n.sons[1].intVal
     let stateNo = c.state.typ.n.sons[1].intVal
diff --git a/compiler/lexer.nim b/compiler/lexer.nim
index 93aea7f61..97414ddb7 100644
--- a/compiler/lexer.nim
+++ b/compiler/lexer.nim
@@ -434,7 +434,7 @@ proc handleHexChar(L: var TLexer, xi: var int) =
   of 'A'..'F': 
     xi = (xi shl 4) or (ord(L.buf[L.bufpos]) - ord('A') + 10)
     inc(L.bufpos)
-  else: nil
+  else: discard
 
 proc handleDecChars(L: var TLexer, xi: var int) = 
   while L.buf[L.bufpos] in {'0'..'9'}: 
diff --git a/compiler/lookups.nim b/compiler/lookups.nim
index 57c420d3b..6dfd25968 100644
--- a/compiler/lookups.nim
+++ b/compiler/lookups.nim
@@ -286,7 +286,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
     o.symChoiceIndex = 1
     o.inSymChoice = initIntSet()
     incl(o.inSymChoice, result.id)
-  else: nil
+  else: discard
   if result != nil and result.kind == skStub: loadStub(result)
 
 proc lastOverloadScope*(o: TOverloadIter): int =
diff --git a/compiler/msgs.nim b/compiler/msgs.nim
index d7944a182..61336aa87 100644
--- a/compiler/msgs.nim
+++ b/compiler/msgs.nim
@@ -113,7 +113,7 @@ type
     warnDifferentHeaps, warnWriteToForeignHeap, warnImplicitClosure,
     warnEachIdentIsTuple, warnShadowIdent, 
     warnProveInit, warnProveField, warnProveIndex,
-    warnUninit, warnUser,
+    warnUninit, warnGcMem, warnUser,
     hintSuccess, hintSuccessX,
     hintLineTooLong, hintXDeclaredButNotUsed, hintConvToBaseNotNeeded,
     hintConvFromXtoItselfNotNeeded, hintExprAlwaysX, hintQuitCalled,
@@ -370,6 +370,7 @@ const
     warnProveField: "cannot prove that field '$1' is accessible [ProveField]",
     warnProveIndex: "cannot prove index '$1' is valid [ProveIndex]",
     warnUninit: "'$1' might not have been initialized [Uninit]",
+    warnGcMem: "'$1' uses GC'ed memory [GcMem]",
     warnUser: "$1 [User]", 
     hintSuccess: "operation successful [Success]", 
     hintSuccessX: "operation successful ($# lines compiled; $# sec total; $#) [SuccessX]", 
@@ -389,7 +390,7 @@ const
     hintUser: "$1 [User]"]
 
 const
-  WarningsToStr*: array[0..23, string] = ["CannotOpenFile", "OctalEscape", 
+  WarningsToStr*: array[0..24, string] = ["CannotOpenFile", "OctalEscape", 
     "XIsNeverRead", "XmightNotBeenInit",
     "Deprecated", "ConfigDeprecated",
     "SmallLshouldNotBeUsed", "UnknownMagic", 
@@ -397,7 +398,7 @@ const
     "CommentXIgnored", "NilStmt",
     "AnalysisLoophole", "DifferentHeaps", "WriteToForeignHeap",
     "ImplicitClosure", "EachIdentIsTuple", "ShadowIdent", 
-    "ProveInit", "ProveField", "ProveIndex", "Uninit", "User"]
+    "ProveInit", "ProveField", "ProveIndex", "Uninit", "GcMem", "User"]
 
   HintsToStr*: array[0..15, string] = ["Success", "SuccessX", "LineTooLong", 
     "XDeclaredButNotUsed", "ConvToBaseNotNeeded", "ConvFromXtoItselfNotNeeded", 
@@ -856,6 +857,5 @@ ropes.errorHandler = proc (err: TRopesError, msg: string, useWarning: bool) =
   of rTokenTooLong:
     internalError("ropes: token too long: " & msg)
   of rCannotOpenFile:
-    rawMessage(if useWarning: warnCannotOpenFile else: errCannotOpenFile,
-               msg)
- 
+    rawMessage(if useWarning: warnCannotOpenFile else: errCannotOpenFile, msg)
+
diff --git a/compiler/nimconf.nim b/compiler/nimconf.nim
index 2bdfbe0b8..136a0d454 100644
--- a/compiler/nimconf.nim
+++ b/compiler/nimconf.nim
@@ -101,11 +101,11 @@ proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
           break 
         if nestedIfs > 0: dec(nestedIfs)
       else: 
-        nil
+        discard
       ppGetTok(L, tok)
-    elif tok.tokType == tkEof: 
+    elif tok.tokType == tkEof:
       lexMessage(L, errTokenExpected, "@end")
-    else: 
+    else:
       ppGetTok(L, tok)
   
 proc parseDirective(L: var TLexer, tok: var TToken) = 
diff --git a/compiler/nimrod.nimrod.cfg b/compiler/nimrod.nimrod.cfg
index b2ae97686..657c47b28 100644
--- a/compiler/nimrod.nimrod.cfg
+++ b/compiler/nimrod.nimrod.cfg
@@ -16,3 +16,5 @@ import:testability
 @if windows:
   cincludes: "$lib/wrappers/libffi/common"
 @end
+
+cs:partial
diff --git a/compiler/parser.nim b/compiler/parser.nim
index e7a15c8ab..c44036c5f 100644
--- a/compiler/parser.nim
+++ b/compiler/parser.nim
@@ -1817,7 +1817,7 @@ proc parseStmt(p: var TParser): PNode =
     withInd(p):
       while true:
         if p.tok.indent == p.currInd:
-          nil
+          discard
         elif p.tok.tokType == tkSemiColon:
           getTok(p)
           if p.tok.indent < 0 or p.tok.indent == p.currInd: discard
diff --git a/compiler/passaux.nim b/compiler/passaux.nim
index 79d11419b..0ba9f22d0 100644
--- a/compiler/passaux.nim
+++ b/compiler/passaux.nim
@@ -41,7 +41,7 @@ proc cleanUp(c: PPassContext, n: PNode): PNode =
       if sfDeadCodeElim notin getModule(s).flags and not astNeeded(s): 
         s.ast.sons[bodyPos] = ast.emptyNode # free the memory
   else: 
-    nil
+    discard
 
 const cleanupPass* = makePass(process = cleanUp, close = cleanUp)
 
diff --git a/compiler/patterns.nim b/compiler/patterns.nim
index 54f8d3af4..d262790ab 100644
--- a/compiler/patterns.nim
+++ b/compiler/patterns.nim
@@ -40,7 +40,7 @@ proc canonKind(n: PNode): TNodeKind =
   of nkCallKinds: result = nkCall
   of nkStrLit..nkTripleStrLit: result = nkStrLit
   of nkFastAsgn: result = nkAsgn
-  else: nil
+  else: discard
 
 proc sameKinds(a, b: PNode): bool {.inline.} =
   result = a.kind == b.kind or a.canonKind == b.canonKind
@@ -267,7 +267,7 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
       var rs = result.sons[i]
       let param = params.sons[i].sym
       case whichAlias(param)
-      of aqNone: nil
+      of aqNone: discard
       of aqShouldAlias:
         # it suffices that it aliases for sure with *some* other param:
         var ok = false
diff --git a/compiler/procfind.nim b/compiler/procfind.nim
index eb0cbca3f..0354d585d 100644
--- a/compiler/procfind.nim
+++ b/compiler/procfind.nim
@@ -60,7 +60,7 @@ proc searchForProcOld*(c: PContext, scope: PScope, fn: PSym): PSym =
           localError(fn.info, errNotOverloadable, fn.name.s)
           return
         of paramsNotEqual:
-          nil
+          discard
       result = nextIdentIter(it, scope.symbols)
 
 proc searchForProcNew(c: PContext, scope: PScope, fn: PSym): PSym =
diff --git a/compiler/renderer.nim b/compiler/renderer.nim
index 6c7d9cae3..b5e3c0e74 100644
--- a/compiler/renderer.nim
+++ b/compiler/renderer.nim
@@ -236,7 +236,7 @@ proc containsNL(s: string): bool =
     of '\x0D', '\x0A': 
       return true
     else: 
-      nil
+      discard
   result = false
 
 proc pushCom(g: var TSrcGen, n: PNode) = 
@@ -487,7 +487,7 @@ proc hasCom(n: PNode): bool =
   result = false
   if n.comment != nil: return true
   case n.kind
-  of nkEmpty..nkNilLit: nil
+  of nkEmpty..nkNilLit: discard
   else: 
     for i in countup(0, sonsLen(n) - 1): 
       if hasCom(n.sons[i]): return true
@@ -769,7 +769,7 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext) =
   if n.comment != nil: pushCom(g, n)
   case n.kind                 # atoms:
   of nkTripleStrLit: putRawStr(g, tkTripleStrLit, n.strVal)
-  of nkEmpty: nil
+  of nkEmpty: discard
   of nkType: put(g, tkInvalid, atom(n))
   of nkSym, nkIdent: gident(g, n)
   of nkIntLit: put(g, tkIntLit, atom(n))
@@ -1273,7 +1273,7 @@ proc renderModule(n: PNode, filename: string,
     case n.sons[i].kind
     of nkTypeSection, nkConstSection, nkVarSection, nkLetSection,
        nkCommentStmt: putNL(g)
-    else: nil
+    else: discard
   gcoms(g)
   if optStdout in gGlobalOptions:
     write(stdout, g.buf)
diff --git a/compiler/rodread.nim b/compiler/rodread.nim
index 7a35f0c84..b53135a95 100644
--- a/compiler/rodread.nim
+++ b/compiler/rodread.nim
@@ -539,7 +539,7 @@ proc cmdChangeTriggersRecompilation(old, new: TCommands): bool =
   of cmdNone, cmdDoc, cmdInterpret, cmdPretty, cmdGenDepend, cmdDump,
       cmdCheck, cmdParse, cmdScan, cmdIdeTools, cmdDef, 
       cmdRst2html, cmdRst2tex, cmdInteractive, cmdRun:
-    nil
+    discard
   # else: trigger recompilation:
   result = true
   
diff --git a/compiler/rodwrite.nim b/compiler/rodwrite.nim
index c393ce1da..4231da2d0 100644
--- a/compiler/rodwrite.nim
+++ b/compiler/rodwrite.nim
@@ -573,7 +573,7 @@ proc process(c: PPassContext, n: PNode): PNode =
   of nkPragma: 
     addStmt(w, n)
   else: 
-    nil
+    discard
 
 proc myOpen(module: PSym): PPassContext =
   if module.id < 0: internalError("rodwrite: module ID not set")
diff --git a/compiler/semcall.nim b/compiler/semcall.nim
index 5990f2e96..6b19dc359 100644
--- a/compiler/semcall.nim
+++ b/compiler/semcall.nim
@@ -71,7 +71,7 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
           var cmp = cmpCandidates(best, z)
           if cmp < 0: best = z   # x is better than the best so far
           elif cmp == 0: alt = z # x is as good as the best so far
-          else: nil
+          else: discard
     sym = nextOverloadIter(o, c, headSymbol)
 
 proc notFoundError*(c: PContext, n: PNode, errors: seq[string]) =
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index 0d74db1ce..6e2d777fb 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -168,7 +168,7 @@ proc checkConvertible(c: PContext, castDest, src: PType): TConvStatus =
       if not compareTypes(castDest, src, dcEqIgnoreDistinct):
         result = convNotLegal
     else:
-      nil
+      discard
 
 proc isCastable(dst, src: PType): bool = 
   #const
@@ -204,7 +204,7 @@ proc semConv(c: PContext, n: PNode): PNode =
   if not isSymChoice(op):
     let status = checkConvertible(c, result.typ, op.typ)
     case status
-    of convOK: nil
+    of convOK: discard
     of convNotNeedeed:
       message(n.info, hintConvFromXtoItselfNotNeeded, result.typ.typeToString)
     of convNotLegal:
@@ -397,7 +397,7 @@ proc changeType(n: PNode, newType: PType, check: bool) =
   of nkPar: 
     if newType.kind != tyTuple: 
       internalError(n.info, "changeType: no tuple type for constructor")
-    elif newType.n == nil: nil
+    elif newType.n == nil: discard
     elif sonsLen(n) > 0 and n.sons[0].kind == nkExprColonExpr: 
       for i in countup(0, sonsLen(n) - 1): 
         var m = n.sons[i].sons[0]
@@ -423,7 +423,7 @@ proc changeType(n: PNode, newType: PType, check: bool) =
       if value < firstOrd(newType) or value > lastOrd(newType):
         localError(n.info, errGenerated, "cannot convert " & $value &
                                          " to " & typeToString(newType))
-  else: nil
+  else: discard
   n.typ = newType
 
 proc arrayConstrType(c: PContext, n: PNode): PType = 
@@ -513,7 +513,7 @@ proc fixAbstractType(c: PContext, n: PNode) =
       # an implicitly constructed array (passed to an open array):
       n.sons[i] = semArrayConstr(c, it, {})
     else: 
-      nil
+      discard
       #if (it.typ == nil): 
       #  InternalError(it.info, "fixAbstractType: " & renderTree(it))  
   
@@ -677,7 +677,7 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
       return
     let callee = result.sons[0].sym
     case callee.kind
-    of skMacro, skTemplate: nil
+    of skMacro, skTemplate: discard
     else:
       if (callee.kind == skIterator) and (callee.id == c.p.owner.id): 
         localError(n.info, errRecursiveDependencyX, callee.name.s)
@@ -1098,7 +1098,7 @@ proc takeImplicitAddr(c: PContext, n: PNode): PNode =
   of nkHiddenDeref, nkDerefExpr: return n.sons[0]
   of nkBracketExpr:
     if len(n) == 1: return n.sons[0]
-  else: nil
+  else: discard
   var valid = isAssignable(c, n)
   if valid != arLValue:
     if valid == arLocalLValue:
@@ -1207,7 +1207,7 @@ proc semProcBody(c: PContext, n: PNode): PNode =
     # transform ``expr`` to ``result = expr``, but not if the expr is already
     # ``result``:
     if result.kind == nkSym and result.sym == c.p.resultSym:
-      nil
+      discard
     elif result.kind == nkNilLit:
       # or ImplicitlyDiscardable(result):
       # new semantic: 'result = x' triggers the void context
@@ -1244,7 +1244,7 @@ proc semYieldVarResult(c: PContext, n: PNode, restype: PType) =
           a.sons[i] = takeImplicitAddr(c, a.sons[i])
         else:
           localError(n.sons[0].info, errXExpected, "tuple constructor")
-  else: nil
+  else: discard
   
 proc semYield(c: PContext, n: PNode): PNode =
   result = n
@@ -1472,7 +1472,7 @@ proc tryExpr(c: PContext, n: PNode,
     result = semExpr(c, n, flags)
     if msgs.gErrorCounter != oldErrorCount: result = nil
   except ERecoverableError:
-    nil
+    discard
   # undo symbol table changes (as far as it's possible):
   c.generics = oldGenerics
   c.inGenericContext = oldInGenericContext
@@ -1590,9 +1590,9 @@ proc semSetConstr(c: PContext, n: PNode): PNode =
           typ = skipTypes(n.sons[i].typ, {tyGenericInst, tyVar, tyOrdinal})
     if not isOrdinalType(typ):
       localError(n.info, errOrdinalTypeExpected)
-      typ = makeRangeType(c, 0, MaxSetElements - 1, n.info)
+      typ = makeRangeType(c, 0, MaxSetElements-1, n.info)
     elif lengthOrd(typ) > MaxSetElements: 
-      typ = makeRangeType(c, 0, MaxSetElements - 1, n.info)
+      typ = makeRangeType(c, 0, MaxSetElements-1, n.info)
     addSonSkipIntLit(result.typ, typ)
     for i in countup(0, sonsLen(n) - 1): 
       var m: PNode
@@ -1629,27 +1629,27 @@ proc semTableConstr(c: PContext, n: PNode): PNode =
   if lastKey != n.len: illFormedAst(n)
   result = semExpr(c, result)
 
-type 
-  TParKind = enum 
+type
+  TParKind = enum
     paNone, paSingle, paTupleFields, paTuplePositions
 
-proc checkPar(n: PNode): TParKind = 
+proc checkPar(n: PNode): TParKind =
   var length = sonsLen(n)
   if length == 0: 
     result = paTuplePositions # ()
   elif length == 1: 
     result = paSingle         # (expr)
-  else: 
+  else:
     if n.sons[0].kind == nkExprColonExpr: result = paTupleFields
     else: result = paTuplePositions
-    for i in countup(0, length - 1): 
-      if result == paTupleFields: 
+    for i in countup(0, length - 1):
+      if result == paTupleFields:
         if (n.sons[i].kind != nkExprColonExpr) or
-            not (n.sons[i].sons[0].kind in {nkSym, nkIdent}): 
+            not (n.sons[i].sons[0].kind in {nkSym, nkIdent}):
           localError(n.sons[i].info, errNamedExprExpected)
           return paNone
-      else: 
-        if n.sons[i].kind == nkExprColonExpr: 
+      else:
+        if n.sons[i].kind == nkExprColonExpr:
           localError(n.sons[i].info, errNamedExprNotAllowed)
           return paNone
 
@@ -1659,8 +1659,7 @@ proc semTupleFieldsConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   typ.n = newNodeI(nkRecList, n.info) # nkIdentDefs
   var ids = initIntSet()
   for i in countup(0, sonsLen(n) - 1):
-    if (n.sons[i].kind != nkExprColonExpr) or
-        not (n.sons[i].sons[0].kind in {nkSym, nkIdent}):
+    if n[i].kind != nkExprColonExpr or n[i][0].kind notin {nkSym, nkIdent}:
       illFormedAst(n.sons[i])
     var id: PIdent
     if n.sons[i].sons[0].kind == nkIdent: id = n.sons[i].sons[0].ident
diff --git a/compiler/semfold.nim b/compiler/semfold.nim
index 1d03e6888..78e5cdd5e 100644
--- a/compiler/semfold.nim
+++ b/compiler/semfold.nim
@@ -222,7 +222,7 @@ proc getIntervalType*(m: TMagic, n: PNode): PType =
     commutativeOp(min)
   of mMaxI, mMaxI64:
     commutativeOp(max)
-  else: nil
+  else: discard
   
 discard """
   mShlI, mShlI64,
@@ -546,7 +546,7 @@ proc foldArrayAccess(m: PSym, n: PNode): PNode =
     if (idx >= 0) and (idx < len(x.strVal)): 
       result.intVal = ord(x.strVal[int(idx)])
     elif idx == len(x.strVal): 
-      nil
+      discard
     else: 
       localError(n.info, errIndexOutOfBounds)
   else: discard
diff --git a/compiler/semmagic.nim b/compiler/semmagic.nim
index a1af94971..4caf1fb8e 100644
--- a/compiler/semmagic.nim
+++ b/compiler/semmagic.nim
@@ -53,7 +53,7 @@ proc semTypeTraits(c: PContext, n: PNode): PNode =
   if t.sonsLen > 0:
     # This is either a type known to sem or a typedesc
     # param to a regular proc (again, known at instantiation)
-    result = evalTypeTrait(n[0], t, GetCurrOwner())
+    result = evalTypeTrait(n[0], t, getCurrOwner())
   else:
     # a typedesc variable, pass unmodified to evals
     result = n
diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index f0007d01e..1aa6a793c 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -136,6 +136,7 @@ proc discardCheck(c: PContext, result: PNode) =
   if result.typ != nil and result.typ.kind notin {tyStmt, tyEmpty}:
     if result.kind == nkNilLit:
       result.typ = nil
+      message(result.info, warnNilStatement)
     elif implicitlyDiscardable(result):
       var n = result
       result.typ = nil
@@ -145,10 +146,11 @@ proc discardCheck(c: PContext, result: PNode) =
     elif c.inTypeClass > 0 and result.typ.kind == tyBool:
       let verdict = semConstExpr(c, result)
       if verdict.intVal == 0:
-        localError(result.info, "type class predicate failed.")
+        localError(result.info, "type class predicate failed")
     elif result.typ.kind != tyError and gCmd != cmdInteractive:
       if result.typ.kind == tyNil:
         fixNilType(result)
+        message(result.info, warnNilStatement)
       else:
         var n = result
         while n.kind in skipForDiscardable: n = n.lastSon
@@ -996,7 +998,7 @@ proc semProcAux(c: PContext, n: PNode, kind: TSymKind,
   if proto == nil: 
     s.typ.callConv = lastOptionEntry(c).defaultCC
     # add it here, so that recursive procs are possible:
-    if sfGenSym in s.flags: nil
+    if sfGenSym in s.flags: discard
     elif kind in OverloadableSyms:
       if not typeIsDetermined:
         addInterfaceOverloadableSymAt(c, s.scope, s)
@@ -1252,9 +1254,9 @@ proc semStmtList(c: PContext, n: PNode): PNode =
       of LastBlockStmts: 
         for j in countup(i + 1, length - 1): 
           case n.sons[j].kind
-          of nkPragma, nkCommentStmt, nkNilLit, nkEmpty: nil
+          of nkPragma, nkCommentStmt, nkNilLit, nkEmpty: discard
           else: localError(n.sons[j].info, errStmtInvalidAfterReturn)
-      else: nil
+      else: discard
   if result.len == 1:
     result = result.sons[0]
   when false:
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index 64c8f81e2..d5a938a12 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -537,7 +537,7 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var TIntSet, pos: var int,
       if a.kind == nkEmpty: addSon(father, newSymNode(f))
       else: addSon(a, newSymNode(f))
     if a.kind != nkEmpty: addSon(father, a)
-  of nkEmpty: nil
+  of nkEmpty: discard
   else: illFormedAst(n)
   
 proc addInheritedFieldsAux(c: PContext, check: var TIntSet, pos: var int, 
@@ -615,7 +615,7 @@ proc addParamOrResult(c: PContext, param: PSym, kind: TSymKind) =
 let typedescId = getIdent"typedesc"
 
 template shouldHaveMeta(t) =
-  InternalAssert tfHasMeta in t.flags
+  internalAssert tfHasMeta in t.flags
   # result.lastSon.flags.incl tfHasMeta
 
 proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
@@ -745,7 +745,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
       else:
         result = addImplicitGeneric(newTypeS(tyAnything, c))
  
-  else: nil
+  else: discard
 
   # result = liftingWalk(paramType)
 
@@ -939,7 +939,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
   result = nil
   if gCmd == cmdIdeTools: suggestExpr(c, n)
   case n.kind
-  of nkEmpty: nil
+  of nkEmpty: discard
   of nkTypeOfExpr:
     # for ``type(countup(1,3))``, see ``tests/ttoseq``.
     checkSonsLen(n, 1)
@@ -977,7 +977,7 @@ proc semTypeNode(c: PContext, n: PNode, prev: PType): PType =
             result = freshType(result, prev)
             result.flags.incl(tfNotNil)
           else:
-            LocalError(n.info, errGenerated, "invalid type")
+            localError(n.info, errGenerated, "invalid type")
         of 2:
           let negated = semTypeNode(c, n.sons[1], prev)
           result = makeNotType(c, negated)
@@ -1137,7 +1137,7 @@ proc processMagicType(c: PContext, m: PSym) =
   of mSet: setMagicType(m, tySet, 0) 
   of mSeq: setMagicType(m, tySequence, 0)
   of mOrdinal: setMagicType(m, tyOrdinal, 0)
-  of mPNimrodNode: nil
+  of mPNimrodNode: discard
   else: localError(m.info, errTypeExpected)
   
 proc semGenericConstraints(c: PContext, x: PType): PType =
diff --git a/compiler/semtypinst.nim b/compiler/semtypinst.nim
index b08119d4a..ac14179cd 100644
--- a/compiler/semtypinst.nim
+++ b/compiler/semtypinst.nim
@@ -22,7 +22,7 @@ proc checkPartialConstructedType(info: TLineInfo, t: PType) =
 
 proc checkConstructedType*(info: TLineInfo, typ: PType) =
   var t = typ.skipTypes({tyDistinct})
-  if t.kind in tyTypeClasses: nil
+  if t.kind in tyTypeClasses: discard
   elif tfAcyclic in t.flags and skipTypes(t, abstractInst).kind != tyObject: 
     localError(info, errInvalidPragmaX, "acyclic")
   elif t.kind == tyVar and t.sons[0].kind == tyVar: 
@@ -364,7 +364,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType =
   of tyGenericInst:
     result = instCopyType(cl, t)
     for i in 1 .. <result.sonsLen:
-      result.sons[i] = ReplaceTypeVarsT(cl, result.sons[i])
+      result.sons[i] = replaceTypeVarsT(cl, result.sons[i])
     propagateToOwner(result, result.lastSon)
   
   else:
diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim
index 7066c5afd..1fe667a3c 100644
--- a/compiler/sigmatch.nim
+++ b/compiler/sigmatch.nim
@@ -381,7 +381,7 @@ proc procTypeRel(c: var TCandidate, f, a: PType): TTypeRelation =
     when useEffectSystem:
       if not compatibleEffects(f, a): return isNone
   of tyNil: result = f.allowsNil
-  else: nil
+  else: discard
 
 proc typeRangeRel(f, a: PType): TTypeRelation {.noinline.} =
   let
@@ -477,7 +477,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
   of tyAnything:
     return if f.kind == tyAnything: isGeneric
            else: isNone
-  else: nil
+  else: discard
 
   case f.kind
   of tyEnum:
@@ -530,7 +530,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
       result = typeRel(c, f.sons[1], a.sons[1])
       if result < isGeneric: result = isNone
       elif lengthOrd(fRange) != lengthOrd(a): result = isNone
-    else: nil
+    else: discard
   of tyOpenArray, tyVarargs:
     case a.kind
     of tyOpenArray, tyVarargs:
@@ -551,7 +551,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
         result = isConvertible
       elif typeRel(c, base(f), a.sons[0]) >= isGeneric: 
         result = isConvertible
-    else: nil
+    else: discard
   of tySequence:
     case a.kind
     of tySequence:
@@ -563,7 +563,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
         elif tfNotNil in f.flags and tfNotNil notin a.flags:
           result = isNilConversion
     of tyNil: result = f.allowsNil
-    else: nil
+    else: discard
   of tyOrdinal:
     if isOrdinalType(a):
       var x = if a.kind == tyOrdinal: a.sons[0] else: a
@@ -607,7 +607,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
       elif tfNotNil in f.flags and tfNotNil notin a.flags:
         result = isNilConversion
     of tyNil: result = f.allowsNil
-    else: nil
+    else: discard
   of tyRef: 
     case a.kind
     of tyRef:
@@ -616,7 +616,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
       elif tfNotNil in f.flags and tfNotNil notin a.flags:
         result = isNilConversion
     of tyNil: result = f.allowsNil
-    else: nil
+    else: discard
   of tyProc:
     result = procTypeRel(c, f, a)
     if result != isNone and tfNotNil in f.flags and tfNotNil notin a.flags:
@@ -632,7 +632,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
     of tyProc:
       if a.callConv != ccClosure: result = isConvertible
     of tyPtr, tyCString: result = isConvertible
-    else: nil
+    else: discard
   of tyString: 
     case a.kind
     of tyString: 
@@ -641,7 +641,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
       else:
         result = isEqual
     of tyNil: result = f.allowsNil
-    else: nil
+    else: discard
   of tyCString:
     # conversion from string to cstring is automatic:
     case a.kind
@@ -659,7 +659,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
           (skipTypes(a.sons[0], {tyRange}).kind in {tyInt..tyInt64}) and
           (a.sons[1].kind == tyChar): 
         result = isConvertible
-    else: nil
+    else: discard
 
   of tyEmpty:
     if a.kind == tyEmpty: result = isEqual
@@ -691,7 +691,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType, doBind = true): TTypeRelation =
     if x.kind == tyGenericInvokation or f.sons[0].kind != tyGenericBody:
       #InternalError("typeRel: tyGenericInvokation -> tyGenericInvokation")
       # simply no match for now:
-      nil
+      discard
     elif x.kind == tyGenericInst and 
           (f.sons[0] == x.sons[0]) and
           (sonsLen(x) - 1 == sonsLen(f)):
@@ -947,10 +947,10 @@ proc matchUserTypeClass*(c: PContext, m: var TCandidate,
     if e == nil: return nil
 
     case e.kind
-    of nkReturnStmt: nil
-    of nkTypeSection: nil
-    of nkConstDef: nil
-    else: nil
+    of nkReturnStmt: discard
+    of nkTypeSection: discard
+    of nkConstDef: discard
+    else: discard
   
   result = arg
   put(m.bindings, f, a)
@@ -976,7 +976,7 @@ proc paramTypesMatchAux(m: var TCandidate, f, argType: PType,
  
   var
     r: TTypeRelation
-    a = if c.InTypeClass > 0: argType.skipTypes({tyTypeDesc})
+    a = if c.inTypeClass > 0: argType.skipTypes({tyTypeDesc})
         else: argType
  
   case fMaybeStatic.kind
diff --git a/compiler/suggest.nim b/compiler/suggest.nim
index 1fde831b7..49611f649 100644
--- a/compiler/suggest.nim
+++ b/compiler/suggest.nim
@@ -103,7 +103,7 @@ proc suggestObject(c: PContext, n: PNode, outputs: var int) =
       suggestObject(c, n.sons[0], outputs)
       for i in countup(1, L-1): suggestObject(c, lastSon(n.sons[i]), outputs)
   of nkSym: suggestField(c, n.sym, outputs)
-  else: nil
+  else: discard
 
 proc nameFits(c: PContext, s: PSym, n: PNode): bool = 
   var op = n.sons[0]
diff --git a/compiler/transf.nim b/compiler/transf.nim
index 2332d0b48..f22433972 100644
--- a/compiler/transf.nim
+++ b/compiler/transf.nim
@@ -193,7 +193,7 @@ proc transformConstSection(c: PTransf, v: PNode): PTransNode =
 
 proc hasContinue(n: PNode): bool = 
   case n.kind
-  of nkEmpty..nkNilLit, nkForStmt, nkParForStmt, nkWhileStmt: nil
+  of nkEmpty..nkNilLit, nkForStmt, nkParForStmt, nkWhileStmt: discard
   of nkContinueStmt: result = true
   else: 
     for i in countup(0, sonsLen(n) - 1): 
@@ -536,7 +536,7 @@ proc getMergeOp(n: PNode): PSym =
     if (n.sons[0].kind == nkSym) and (n.sons[0].sym.kind == skProc) and
         (sfMerge in n.sons[0].sym.flags): 
       result = n.sons[0].sym
-  else: nil
+  else: discard
 
 proc flattenTreeAux(d, a: PNode, op: PSym) = 
   var op2 = getMergeOp(a)
diff --git a/compiler/types.nim b/compiler/types.nim
index 36c9f1934..d7310596f 100644
--- a/compiler/types.nim
+++ b/compiler/types.nim
@@ -345,7 +345,7 @@ proc canFormAcycleAux(marker: var TIntSet, typ: PType, startId: int): bool =
     #  # damn inheritance may introduce cycles:
     #  result = true
   of tyProc: result = typ.callConv == ccClosure
-  else: nil
+  else: discard
 
 proc canFormAcycle(typ: PType): bool =
   var marker = initIntSet()
@@ -432,10 +432,10 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
     if t.len == 0: result = "typedesc"
     else: result = "typedesc[" & typeToString(t.sons[0]) & "]"
   of tyStatic:
-    InternalAssert t.len > 0
+    internalAssert t.len > 0
     result = "static[" & typeToString(t.sons[0]) & "]"
   of tyTypeClass:
-    InternalAssert t.sym != nil and t.sym.owner != nil
+    internalAssert t.sym != nil and t.sym.owner != nil
     return t.sym.owner.name.s
   of tyBuiltInTypeClass:
     return "TypeClass"
@@ -446,7 +446,7 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
   of tyNot:
     result = "not " & typeToString(t.sons[0])
   of tyExpr:
-    InternalAssert t.len == 0
+    internalAssert t.len == 0
     result = "expr"
   of tyFromExpr:
     result = renderTree(t.n)
diff --git a/doc/manual.txt b/doc/manual.txt
index f6dd1f521..c90373233 100644
--- a/doc/manual.txt
+++ b/doc/manual.txt
@@ -1333,7 +1333,7 @@ Examples:
     # has default calling convention
     echo "x: ", mouseX, " y: ", mouseY
   
-  proc setOnMouseMove(mouseMoveEvent: TOnMouseMove) = nil
+  proc setOnMouseMove(mouseMoveEvent: TOnMouseMove) = discard
   
   # ok, 'onMouseMove' has the default calling convention, which is compatible
   # to 'closure':
diff --git a/doc/tut1.txt b/doc/tut1.txt
index 2e7f9d27f..1ba3253c8 100644
--- a/doc/tut1.txt
+++ b/doc/tut1.txt
@@ -324,12 +324,12 @@ the compiler that for every other value nothing should be done:
   case n
   of 0..2, 4..7: echo("The number is in the set: {0, 1, 2, 4, 5, 6, 7}")
   of 3, 8: echo("The number is 3 or 8")
-  else: nil
+  else: discard
 
-The ``nil`` statement is a *do nothing* statement. The compiler knows that a
-case statement with an else part cannot fail and thus the error disappears. Note
-that it is impossible to cover all possible string values: that is why there is
-no such check for string cases.
+The empty ``discard`` statement is a *do nothing* statement. The compiler knows
+that a case statement with an else part cannot fail and thus the error 
+disappears. Note that it is impossible to cover all possible string values: 
+that is why there is no such check for string cases.
 
 In general the case statement is used for subrange types or enumerations where
 it is of great help that the compiler checks that you covered any possible
diff --git a/doc/tut2.txt b/doc/tut2.txt
index f8fa4aef3..581239cc7 100644
--- a/doc/tut2.txt
+++ b/doc/tut2.txt
@@ -614,7 +614,7 @@ simple proc for logging:
 
 .. code-block:: nimrod
   const
-    debug = True
+    debug = true
 
   proc log(msg: string) {.inline.} =
     if debug: stdout.writeln(msg)
@@ -631,7 +631,7 @@ Turning the ``log`` proc into a template solves this problem:
 
 .. code-block:: nimrod
   const
-    debug = True
+    debug = true
 
   template log(msg: string) =
     if debug: stdout.writeln(msg)
@@ -674,16 +674,15 @@ via a special ``:`` syntax:
 
   template withFile(f: expr, filename: string, mode: TFileMode,
                     body: stmt): stmt {.immediate.} =
-    block:
-      let fn = filename
-      var f: TFile
-      if open(f, fn, mode):
-        try:
-          body
-        finally:
-          close(f)
-      else:
-        quit("cannot open: " & fn)
+    let fn = filename
+    var f: TFile
+    if open(f, fn, mode):
+      try:
+        body
+      finally:
+        close(f)
+    else:
+      quit("cannot open: " & fn)
       
   withFile(txt, "ttempl3.txt", fmWrite):
     txt.writeln("line 1")
@@ -784,7 +783,7 @@ regular expressions:
   macro case_token(n: stmt): stmt =
     # creates a lexical analyzer from regular expressions
     # ... (implementation is an exercise for the reader :-)
-    nil
+    discard
 
   case_token: # this colon tells the parser it is a macro statement
   of r"[A-Za-z_]+[A-Za-z_0-9]*":
diff --git a/lib/packages/docutils/highlite.nim b/lib/packages/docutils/highlite.nim
index b41a37309..db7a63928 100644
--- a/lib/packages/docutils/highlite.nim
+++ b/lib/packages/docutils/highlite.nim
@@ -73,7 +73,7 @@ proc initGeneralTokenizer*(g: var TGeneralTokenizer, buf: string) =
   g.pos = pos
 
 proc deinitGeneralTokenizer*(g: var TGeneralTokenizer) = 
-  nil
+  discard
 
 proc nimGetKeyword(id: string): TTokenClass = 
   for k in nimrodKeywords:
@@ -102,7 +102,7 @@ proc nimNumberPostfix(g: var TGeneralTokenizer, position: int): int =
       if g.buf[pos] in {'0'..'9'}: inc(pos)
       if g.buf[pos] in {'0'..'9'}: inc(pos)
     else: 
-      nil
+      discard
   result = pos
 
 proc nimNumber(g: var TGeneralTokenizer, position: int): int = 
diff --git a/lib/packages/docutils/rst.nim b/lib/packages/docutils/rst.nim
index e6ffadcbd..bb018bc1e 100644
--- a/lib/packages/docutils/rst.nim
+++ b/lib/packages/docutils/rst.nim
@@ -535,7 +535,7 @@ proc match(p: TRstParser, start: int, expr: string): bool =
         case p.tok[j].symbol[0]
         of 'a'..'z', 'A'..'Z': result = len(p.tok[j].symbol) == 1
         of '0'..'9': result = allCharsInSet(p.tok[j].symbol, {'0'..'9'})
-        else: nil
+        else: discard
     else: 
       var c = expr[i]
       var length = 0
@@ -640,7 +640,7 @@ proc parseUrl(p: var TRstParser, father: PRstNode) =
     var n = newRstNode(rnStandaloneHyperlink)
     while true: 
       case p.tok[p.idx].kind
-      of tkWord, tkAdornment, tkOther: nil
+      of tkWord, tkAdornment, tkOther: discard
       of tkPunct: 
         if p.tok[p.idx+1].kind notin {tkWord, tkAdornment, tkOther, tkPunct}:
           break
@@ -806,7 +806,7 @@ proc parseInline(p: var TRstParser, father: PRstNode) =
         return
     add(father, newLeaf(p))
     inc(p.idx)
-  else: nil
+  else: discard
   
 proc getDirective(p: var TRstParser): string = 
   if p.tok[p.idx].kind == tkWhite and p.tok[p.idx+1].kind == tkWord: 
@@ -1339,7 +1339,7 @@ proc parseSection(p: var TRstParser, result: PRstNode) =
     of rnDirective: a = parseDotDot(p)
     of rnEnumList: a = parseEnumList(p)
     of rnLeaf: rstMessage(p, meNewSectionExpected)
-    of rnParagraph: nil
+    of rnParagraph: discard
     of rnDefList: a = parseDefinitionList(p)
     of rnFieldList: 
       if p.idx > 0: dec(p.idx)
@@ -1351,7 +1351,7 @@ proc parseSection(p: var TRstParser, result: PRstNode) =
     of rnOptionList: a = parseOptionList(p)
     else:
       #InternalError("rst.parseSection()")
-      nil
+      discard
     if a == nil and k != rnDirective: 
       a = newRstNode(rnParagraph)
       parseParagraph(p, a)
@@ -1624,7 +1624,7 @@ proc resolveSubs(p: var TRstParser, n: PRstNode): PRstNode =
       add(result, n)
       add(result, y)
   of rnLeaf: 
-    nil
+    discard
   of rnContents: 
     p.hasToc = true
   else: 
diff --git a/lib/packages/docutils/rstgen.nim b/lib/packages/docutils/rstgen.nim
index a56f62448..5c09d521e 100644
--- a/lib/packages/docutils/rstgen.nim
+++ b/lib/packages/docutils/rstgen.nim
@@ -165,7 +165,7 @@ proc nextSplitPoint*(s: string, start: int): int =
     of 'a'..'z': 
       if result + 1 < len(s) + 0: 
         if s[result + 1] in {'A'..'Z'}: return 
-    else: nil
+    else: discard
     inc(result)
   dec(result)                 # last valid index
   
diff --git a/lib/pure/json.nim b/lib/pure/json.nim
index 360a3a5e7..7424bbae9 100644
--- a/lib/pure/json.nim
+++ b/lib/pure/json.nim
@@ -626,7 +626,7 @@ proc len*(n: PJsonNode): int =
   case n.kind
   of JArray: result = n.elems.len
   of JObject: result = n.fields.len
-  else: nil
+  else: discard
 
 proc `[]`*(node: PJsonNode, name: string): PJsonNode =
   ## Gets a field from a `JObject`. Returns nil if the key is not found.
@@ -646,6 +646,7 @@ proc hasKey*(node: PJsonNode, key: string): bool =
   assert(node.kind == JObject)
   for k, item in items(node.fields):
     if k == key: return true
+
 proc existsKey*(node: PJsonNode, key: string): bool {.deprecated.} = node.hasKey(key)
   ## Deprecated for `hasKey`
 
diff --git a/lib/pure/osproc.nim b/lib/pure/osproc.nim
index fe4303d8a..7b59deec7 100644
--- a/lib/pure/osproc.nim
+++ b/lib/pure/osproc.nim
@@ -329,7 +329,7 @@ when defined(Windows) and not defined(useNimRtl):
       handle: THandle
       atTheEnd: bool
 
-  proc hsClose(s: PStream) = nil # nothing to do here
+  proc hsClose(s: PStream) = discard # nothing to do here
   proc hsAtEnd(s: PStream): bool = return PFileHandleStream(s).atTheEnd
 
   proc hsReadData(s: PStream, buffer: pointer, bufLen: int): int =
diff --git a/lib/pure/parseutils.nim b/lib/pure/parseutils.nim
index 6423b3ab0..484ba5184 100644
--- a/lib/pure/parseutils.nim
+++ b/lib/pure/parseutils.nim
@@ -370,7 +370,7 @@ iterator interpolatedFragments*(s: string): tuple[kind: TInterpolatedKind,
           of '\0':
             raise newException(EInvalidValue, 
               "Expected closing '}': " & s[i..s.len])
-          else: nil
+          else: discard
           inc j
         inc i, 2 # skip ${
         kind = ikExpr
diff --git a/lib/pure/sockets.nim b/lib/pure/sockets.nim
index de445dd36..b56153cc0 100644
--- a/lib/pure/sockets.nim
+++ b/lib/pure/sockets.nim
@@ -1523,7 +1523,7 @@ proc skip*(socket: TSocket) {.tags: [FReadIO], deprecated.} =
   ## **Deprecated since version 0.9.2**: This function is not safe for use.
   const bufSize = 1000
   var buf = alloc(bufSize)
-  while recv(socket, buf, bufSize) == bufSize: nil
+  while recv(socket, buf, bufSize) == bufSize: discard
   dealloc(buf)
 
 proc skip*(socket: TSocket, size: int, timeout = -1) =
diff --git a/lib/pure/streams.nim b/lib/pure/streams.nim
index 302742eb4..e944dd2fc 100644
--- a/lib/pure/streams.nim
+++ b/lib/pure/streams.nim
@@ -281,7 +281,7 @@ proc newFileStream*(filename: string, mode: TFileMode): PFileStream =
 
 
 when true:
-  nil
+  discard
 else:
   type
     TFileHandle* = cint ## Operating system file handle
diff --git a/lib/pure/strutils.nim b/lib/pure/strutils.nim
index 20109cfa2..de8dc5e51 100644
--- a/lib/pure/strutils.nim
+++ b/lib/pure/strutils.nim
@@ -304,7 +304,7 @@ proc countLines*(s: string): int {.noSideEffect,
       if s[i+1] == '\l': inc i
       inc result
     of '\l': inc result
-    else: nil
+    else: discard
     inc i
 
 proc split*(s: string, seps: set[char] = Whitespace): seq[string] {.
diff --git a/lib/pure/times.nim b/lib/pure/times.nim
index be3e5d6da..6186fcad8 100644
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -698,7 +698,7 @@ proc format*(info: TTimeInfo, f: string): string =
       of "ZZZ":
         result.add(info.tzname)
       of "":
-        nil # Do nothing.
+        discard
       else:
         raise newException(EInvalidValue, "Invalid format string: " & currentF)
       
diff --git a/lib/system/gc.nim b/lib/system/gc.nim
index 0fb9bb482..820093b3e 100644
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -1029,11 +1029,7 @@ when not defined(useNimRtl):
         dec(gch.recGcLock)
 
   proc GC_setStrategy(strategy: TGC_Strategy) =
-    case strategy
-    of gcThroughput: nil
-    of gcResponsiveness: nil
-    of gcOptimizeSpace: nil
-    of gcOptimizeTime: nil
+    discard
 
   proc GC_enableMarkAndSweep() =
     gch.cycleThreshold = InitialCycleThreshold
diff --git a/web/news.txt b/web/news.txt
index c518bfc95..ce5f80fd2 100644
--- a/web/news.txt
+++ b/web/news.txt
@@ -3,7 +3,7 @@ News
 ====
 
 
-2013-XX-XX Version 0.9.4 released
+2014-XX-XX Version 0.9.4 released
 =================================
 
 
@@ -37,6 +37,7 @@ Changes affecting backwards compatibility
   passed to shell, instead of just adding double quotes.
 - ``macros.dumpTree`` and ``macros.dumpLisp`` have been made ``immediate``,
   ``dumpTreeImm`` and ``dumpLispImm`` are now deprecated.
+- The ``nil`` statement has been deprecated, use an empty ``discard`` instead.
 
 
 Compiler Additions
@@ -68,7 +69,7 @@ Language Additions
   fields at compile-time.
 - The overload resolution now supports ``static[T]`` params that must be
   evaluatable at compile-time.
-- Support for user-defined type classes have been added.
+- Support for user-defined type classes has been added.
 
 
 Tools improvements