mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-09-11 07:55:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

use strictdefs for compiler (#22365)

Browse Source 
* wip; use strictdefs for compiler

* checkpoint

* complete the chores

* more fixes

* first phase cleanup

* Update compiler/bitsets.nim

* cleanup
This commit is contained in:
ringabout
2023-08-06 20:26:21 +08:00
committed by GitHub
parent 53586d1f32
commit 93ced31353
114 changed files with 1223 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/aliasanalysis.nim
View File

@@ -74,7 +74,7 @@ proc aliases*(obj, field: PNode): AliasKind =
# x[i] -> x[i]: maybe; Further analysis could make this return true when i is a runtime-constant
# x[i] -> x[j]: maybe; also returns maybe if only one of i or j is a compiletime-constant
template collectImportantNodes(result, n) =
var result: seq[PNode]
var result: seq[PNode] = @[]
var n = n
while true:
case n.kind

13
compiler/aliases.nim
View File

@@ -114,6 +114,8 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
# use expensive type check:
if isPartOf(a.sym.typ, b.sym.typ) != arNo:
result = arMaybe
else:
result = arNo
of nkBracketExpr:
result = isPartOf(a[0], b[0])
if a.len >= 2 and b.len >= 2:
@@ -149,7 +151,7 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
result = isPartOf(a[1], b[1])
of nkObjUpConv, nkObjDownConv, nkCheckedFieldExpr:
result = isPartOf(a[0], b[0])
else: discard
else: result = arNo
# Calls return a new location, so a default of ``arNo`` is fine.
else:
# go down recursively; this is quite demanding:
@@ -165,6 +167,7 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
of DerefKinds:
# a* !<| b[] iff
result = arNo
if isPartOf(a.typ, b.typ) != arNo:
result = isPartOf(a, b[0])
if result == arNo: result = arMaybe
@@ -186,7 +189,9 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
if isPartOf(a.typ, b.typ) != arNo:
result = isPartOf(a[0], b)
if result == arNo: result = arMaybe
else: discard
else:
result = arNo
else: result = arNo
of nkObjConstr:
result = arNo
for i in 1..<b.len:
@@ -204,4 +209,6 @@ proc isPartOf*(a, b: PNode): TAnalysisResult =
of nkBracket:
if b.len > 0:
result = isPartOf(a, b[0])
else: discard
else:
result = arNo
else: result = arNo

16
compiler/ast.nim
View File

@@ -1036,6 +1036,8 @@ proc comment*(n: PNode): string =
if nfHasComment in n.flags and not gconfig.useIc:
# IC doesn't track comments, see `packed_ast`, so this could fail
result = gconfig.comments[n.nodeId]
else:
result = ""
proc `comment=`*(n: PNode, a: string) =
let id = n.nodeId
@@ -1222,6 +1224,7 @@ proc getDeclPragma*(n: PNode): PNode =
case n.kind
of routineDefs:
if n[pragmasPos].kind != nkEmpty: result = n[pragmasPos]
else: result = nil
of nkTypeDef:
#[
type F3*{.deprecated: "x3".} = int
@@ -1241,6 +1244,8 @@ proc getDeclPragma*(n: PNode): PNode =
]#
if n[0].kind == nkPragmaExpr:
result = n[0][1]
else:
result = nil
else:
# support as needed for `nkIdentDefs` etc.
result = nil
@@ -1256,6 +1261,12 @@ proc extractPragma*(s: PSym): PNode =
if s.ast[0].kind == nkPragmaExpr and s.ast[0].len > 1:
# s.ast = nkTypedef / nkPragmaExpr / [nkSym, nkPragma]
result = s.ast[0][1]
else:
result = nil
else:
result = nil
else:
result = nil
assert result == nil or result.kind == nkPragma
proc skipPragmaExpr*(n: PNode): PNode =
@@ -1602,6 +1613,7 @@ proc initStrTable*(x: var TStrTable) =
newSeq(x.data, StartSize)
proc newStrTable*: TStrTable =
result = default(TStrTable)
initStrTable(result)
proc initIdTable*(x: var TIdTable) =
@@ -1609,6 +1621,7 @@ proc initIdTable*(x: var TIdTable) =
newSeq(x.data, StartSize)
proc newIdTable*: TIdTable =
result = default(TIdTable)
initIdTable(result)
proc resetIdTable*(x: var TIdTable) =
@@ -1811,6 +1824,7 @@ proc hasNilSon*(n: PNode): bool =
result = false
proc containsNode*(n: PNode, kinds: TNodeKinds): bool =
result = false
if n == nil: return
case n.kind
of nkEmpty..nkNilLit: result = n.kind in kinds
@@ -2012,6 +2026,8 @@ proc isImportedException*(t: PType; conf: ConfigRef): bool =
if base.sym != nil and {sfCompileToCpp, sfImportc} * base.sym.flags != {}:
result = true
else:
result = false
proc isInfixAs*(n: PNode): bool =
return n.kind == nkInfix and n[0].kind == nkIdent and n[0].ident.s == "as"

5
compiler/astalgo.nim
View File

@@ -197,6 +197,7 @@ proc getSymFromList*(list: PNode, ident: PIdent, start: int = 0): PSym =
result = nil
proc sameIgnoreBacktickGensymInfo(a, b: string): bool =
result = false
if a[0] != b[0]: return false
var alen = a.len - 1
while alen > 0 and a[alen] != '`': dec(alen)
@@ -230,6 +231,7 @@ proc getNamedParamFromList*(list: PNode, ident: PIdent): PSym =
## result.add newIdentNode(getIdent(c.ic, x.name.s & "\`gensym" & $x.id),
## if c.instLines: actual.info else: templ.info)
## ```
result = nil
for i in 1..<list.len:
let it = list[i].sym
if it.name.id == ident.id or
@@ -327,8 +329,10 @@ proc typeToYamlAux(conf: ConfigRef; n: PType, marker: var IntSet, indent: int,
maxRecDepth: int): Rope =
var sonsRope: Rope
if n == nil:
result = ""
sonsRope = rope("null")
elif containsOrIncl(marker, n.id):
result = ""
sonsRope = "\"$1 @$2\"" % [rope($n.kind), rope(
strutils.toHex(cast[int](n), sizeof(n) * 2))]
else:
@@ -1063,6 +1067,7 @@ proc isAddrNode*(n: PNode): bool =
else: false
proc listSymbolNames*(symbols: openArray[PSym]): string =
result = ""
for sym in symbols:
if result.len > 0:
result.add ", "

1
compiler/bitsets.nim
View File

@@ -87,5 +87,6 @@ const populationCount: array[uint8, uint8] = block:
arr
proc bitSetCard*(x: TBitSet): BiggestInt =
result = 0
for it in x:
result.inc int(populationCount[it])

1
compiler/btrees.nim
View File

@@ -38,6 +38,7 @@ template less(a, b): bool = cmp(a, b) < 0
template eq(a, b): bool = cmp(a, b) == 0
proc getOrDefault*[Key, Val](b: BTree[Key, Val], key: Key): Val =
result = default(Val)
var x = b.root
while x.isInternal:
for j in 0..<x.entries:

47
compiler/ccgcalls.nim
View File

@@ -46,6 +46,7 @@ proc preventNrvo(p: BProc; dest, le, ri: PNode): bool =
# cannot analyse the location; assume the worst
return true
result = false
if le != nil:
for i in 1..<ri.len:
let r = ri[i]
@@ -95,7 +96,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
pl.add(");\n")
line(p, cpsStmts, pl)
else:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, typ[0], tmp, needsInit=true)
pl.add(addrLoc(p.config, tmp))
pl.add(");\n")
@@ -132,9 +133,9 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
genAssignment(p, d, list, {}) # no need for deep copying
if canRaise: raiseExit(p)
else:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, typ[0], tmp, needsInit=true)
var list: TLoc
var list: TLoc = default(TLoc)
initLoc(list, locCall, d.lode, OnUnknown)
list.r = pl
genAssignment(p, tmp, list, {}) # no need for deep copying
@@ -157,7 +158,7 @@ proc reifiedOpenArray(n: PNode): bool {.inline.} =
result = true
proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareForMutation = false): (Rope, Rope) =
var a, b, c: TLoc
var a, b, c: TLoc = default(TLoc)
initLocExpr(p, q[1], a)
initLocExpr(p, q[2], b)
initLocExpr(p, q[3], c)
@@ -205,6 +206,7 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
[rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, rdLoc(a))],
lengthExpr)
else:
result = ("", "")
internalError(p.config, "openArrayLoc: " & typeToString(a.t))
proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
@@ -224,7 +226,7 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
let (x, y) = genOpenArraySlice(p, q, formalType, n.typ[0])
result.add x & ", " & y
else:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n, a)
case skipTypes(a.t, abstractVar+{tyStatic}).kind
of tyOpenArray, tyVarargs:
@@ -271,22 +273,24 @@ proc withTmpIfNeeded(p: BProc, a: TLoc, needsTmp: bool): TLoc =
# Also don't regress for non ARC-builds, too risky.
if needsTmp and a.lode.typ != nil and p.config.selectedGC in {gcArc, gcAtomicArc, gcOrc} and
getSize(p.config, a.lode.typ) < 1024:
result = default(TLoc)
getTemp(p, a.lode.typ, result, needsInit=false)
genAssignment(p, result, a, {})
else:
result = a
proc literalsNeedsTmp(p: BProc, a: TLoc): TLoc =
result = default(TLoc)
getTemp(p, a.lode.typ, result, needsInit=false)
genAssignment(p, result, a, {})
proc genArgStringToCString(p: BProc, n: PNode; result: var Rope; needsTmp: bool) {.inline.} =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
appcg(p.module, result, "#nimToCStringConv($1)", [withTmpIfNeeded(p, a, needsTmp).rdLoc])
proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; needsTmp = false) =
var a: TLoc
var a: TLoc = default(TLoc)
if n.kind == nkStringToCString:
genArgStringToCString(p, n, result, needsTmp)
elif skipTypes(param.typ, abstractVar).kind in {tyOpenArray, tyVarargs}:
@@ -317,7 +321,7 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
#assert result != nil
proc genArgNoParam(p: BProc, n: PNode; result: var Rope; needsTmp = false) =
var a: TLoc
var a: TLoc = default(TLoc)
if n.kind == nkStringToCString:
genArgStringToCString(p, n, result, needsTmp)
else:
@@ -327,6 +331,7 @@ proc genArgNoParam(p: BProc, n: PNode; result: var Rope; needsTmp = false) =
import aliasanalysis
proc potentialAlias(n: PNode, potentialWrites: seq[PNode]): bool =
result = false
for p in potentialWrites:
if p.aliases(n) != no or n.aliases(p) != no:
return true
@@ -382,13 +387,13 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
# We must generate temporaries in cases like #14396
# to keep the strict Left-To-Right evaluation
var needTmp = newSeq[bool](ri.len - 1)
var potentialWrites: seq[PNode]
var potentialWrites: seq[PNode] = @[]
for i in countdown(ri.len - 1, 1):
if ri[i].skipTrivialIndirections.kind == nkSym:
needTmp[i - 1] = potentialAlias(ri[i], potentialWrites)
else:
#if not ri[i].typ.isCompileTimeOnly:
var potentialReads: seq[PNode]
var potentialReads: seq[PNode] = @[]
getPotentialReads(ri[i], potentialReads)
for n in potentialReads:
if not needTmp[i - 1]:
@@ -420,7 +425,7 @@ proc addActualSuffixForHCR(res: var Rope, module: PSym, sym: PSym) =
res = res & "_actual".rope
proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
var op: TLoc
var op: TLoc = default(TLoc)
# this is a hotspot in the compiler
initLocExpr(p, ri[0], op)
# getUniqueType() is too expensive here:
@@ -444,7 +449,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
const PatProc = "$1.ClE_0? $1.ClP_0($3$1.ClE_0):(($4)($1.ClP_0))($2)"
const PatIter = "$1.ClP_0($3$1.ClE_0)" # we know the env exists
var op: TLoc
var op: TLoc = default(TLoc)
initLocExpr(p, ri[0], op)
# getUniqueType() is too expensive here:
@@ -478,7 +483,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
genCallPattern()
if canRaise: raiseExit(p)
else:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, typ[0], tmp, needsInit=true)
pl.add(addrLoc(p.config, tmp))
genCallPattern()
@@ -487,7 +492,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
elif isHarmlessStore(p, canRaise, d):
if d.k == locNone: getTemp(p, typ[0], d)
assert(d.t != nil) # generate an assignment to d:
var list: TLoc
var list: TLoc = default(TLoc)
initLoc(list, locCall, d.lode, OnUnknown)
if tfIterator in typ.flags:
list.r = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
@@ -496,10 +501,10 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
genAssignment(p, d, list, {}) # no need for deep copying
if canRaise: raiseExit(p)
else:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, typ[0], tmp)
assert(d.t != nil) # generate an assignment to d:
var list: TLoc
var list: TLoc = default(TLoc)
initLoc(list, locCall, d.lode, OnUnknown)
if tfIterator in typ.flags:
list.r = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
@@ -668,7 +673,7 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Ro
inc j
inc i
of '\'':
var idx, stars: int
var idx, stars: int = 0
if scanCppGenericSlot(pat, i, idx, stars):
var t = resolveStarsInCppType(typ, idx, stars)
if t == nil: result.add("void")
@@ -682,7 +687,7 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Ro
result.add(substr(pat, start, i - 1))
proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
var op: TLoc
var op: TLoc = default(TLoc)
initLocExpr(p, ri[0], op)
# getUniqueType() is too expensive here:
var typ = skipTypes(ri[0].typ, abstractInst)
@@ -728,7 +733,7 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
# generates a crappy ObjC call
var op: TLoc
var op: TLoc = default(TLoc)
initLocExpr(p, ri[0], op)
var pl = "["
# getUniqueType() is too expensive here:
@@ -777,7 +782,7 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
pl.add("];\n")
line(p, cpsStmts, pl)
else:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, typ[0], tmp, needsInit=true)
pl.add(addrLoc(p.config, tmp))
pl.add("];\n")
@@ -787,7 +792,7 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
pl.add("]")
if d.k == locNone: getTemp(p, typ[0], d)
assert(d.t != nil) # generate an assignment to d:
var list: TLoc
var list: TLoc = default(TLoc)
initLoc(list, locCall, ri, OnUnknown)
list.r = pl
genAssignment(p, d, list, {}) # no need for deep copying

221
compiler/ccgexprs.nim
View File

@@ -173,7 +173,9 @@ proc getStorageLoc(n: PNode): TStorageLoc =
of tyVar, tyLent: result = OnUnknown
of tyPtr: result = OnStack
of tyRef: result = OnHeap
else: doAssert(false, "getStorageLoc")
else:
result = OnUnknown
doAssert(false, "getStorageLoc")
of nkBracketExpr, nkDotExpr, nkObjDownConv, nkObjUpConv:
result = getStorageLoc(n[0])
else: result = OnUnknown
@@ -215,9 +217,12 @@ proc asgnComplexity(n: PNode): int =
# 'case objects' are too difficult to inline their assignment operation:
result = 100
of nkRecList:
result = 0
for t in items(n):
result += asgnComplexity(t)
else: discard
else: result = 0
else:
result = 0
proc optAsgnLoc(a: TLoc, t: PType, field: Rope): TLoc =
assert field != ""
@@ -343,7 +348,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
linefmt(p, cpsStmts, "$1 = #copyString($2);$n", [dest.rdLoc, src.rdLoc])
elif dest.storage == OnHeap:
# we use a temporary to care for the dreaded self assignment:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, ty, tmp)
linefmt(p, cpsStmts, "$3 = $1; $1 = #copyStringRC1($2);$n",
[dest.rdLoc, src.rdLoc, tmp.rdLoc])
@@ -426,7 +431,7 @@ proc genAssignment(p: BProc, dest, src: TLoc, flags: TAssignmentFlags) =
proc genDeepCopy(p: BProc; dest, src: TLoc) =
template addrLocOrTemp(a: TLoc): Rope =
if a.k == locExpr:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
getTemp(p, a.t, tmp)
genAssignment(p, tmp, a, {})
addrLoc(p.config, tmp)
@@ -474,7 +479,7 @@ proc putLocIntoDest(p: BProc, d: var TLoc, s: TLoc) =
d = s # ``d`` is free, so fill it with ``s``
proc putDataIntoDest(p: BProc, d: var TLoc, n: PNode, r: Rope) =
var a: TLoc
var a: TLoc = default(TLoc)
if d.k != locNone:
# need to generate an assignment here
initLoc(a, locData, n, OnStatic)
@@ -489,7 +494,7 @@ proc putDataIntoDest(p: BProc, d: var TLoc, n: PNode, r: Rope) =
d.r = r
proc putIntoDest(p: BProc, d: var TLoc, n: PNode, r: Rope; s=OnUnknown) =
var a: TLoc
var a: TLoc = default(TLoc)
if d.k != locNone:
# need to generate an assignment here
initLoc(a, locExpr, n, s)
@@ -504,27 +509,27 @@ proc putIntoDest(p: BProc, d: var TLoc, n: PNode, r: Rope; s=OnUnknown) =
d.r = r
proc binaryStmt(p: BProc, e: PNode, d: var TLoc, op: string) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
if d.k != locNone: internalError(p.config, e.info, "binaryStmt")
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
lineCg(p, cpsStmts, "$1 $2 $3;$n", [rdLoc(a), op, rdLoc(b)])
proc binaryStmtAddr(p: BProc, e: PNode, d: var TLoc, cpname: string) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
if d.k != locNone: internalError(p.config, e.info, "binaryStmtAddr")
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
lineCg(p, cpsStmts, "#$1($2, $3);$n", [cpname, byRefLoc(p, a), rdLoc(b)])
template unaryStmt(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc
var a: TLoc = default(TLoc)
if d.k != locNone: internalError(p.config, e.info, "unaryStmt")
initLocExpr(p, e[1], a)
lineCg(p, cpsStmts, frmt, [rdLoc(a)])
template binaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -532,7 +537,7 @@ template binaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) =
putIntoDest(p, d, e, ropecg(p.module, frmt, [rdLoc(a), rdLoc(b)]))
template binaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -540,12 +545,12 @@ template binaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
putIntoDest(p, d, e, ropecg(p.module, frmt, [a.rdCharLoc, b.rdCharLoc]))
template unaryExpr(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
putIntoDest(p, d, e, ropecg(p.module, frmt, [rdLoc(a)]))
template unaryExprChar(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
putIntoDest(p, d, e, ropecg(p.module, frmt, [rdCharLoc(a)]))
@@ -586,7 +591,7 @@ proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
"nimAddInt64", "nimSubInt64"
]
opr: array[mAddI..mPred, string] = ["+", "-", "*", "/", "%", "+", "-"]
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -621,7 +626,7 @@ proc binaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
var
a: TLoc
a: TLoc = default(TLoc)
t: PType
assert(e[1].typ != nil)
initLocExpr(p, e[1], a)
@@ -646,8 +651,8 @@ proc unaryArithOverflow(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
var
a, b: TLoc
s, k: BiggestInt
a, b: TLoc = default(TLoc)
s, k: BiggestInt = 0
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -705,7 +710,7 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
assert(false, $op)
proc genEqProc(p: BProc, e: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -725,7 +730,7 @@ proc genIsNil(p: BProc, e: PNode, d: var TLoc) =
proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
var
a: TLoc
a: TLoc = default(TLoc)
t: PType
assert(e[1].typ != nil)
initLocExpr(p, e[1], a)
@@ -762,7 +767,7 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
if e[0].typ.skipTypes(abstractInstOwned).kind == tyRef:
d.storage = OnHeap
else:
var a: TLoc
var a: TLoc = default(TLoc)
var typ = e[0].typ
if typ.kind in {tyUserTypeClass, tyUserTypeClassInst} and typ.isResolvedUserTypeClass:
typ = typ.lastSon
@@ -808,7 +813,7 @@ proc cowBracket(p: BProc; n: PNode) =
if n.kind == nkBracketExpr and optSeqDestructors in p.config.globalOptions:
let strCandidate = n[0]
if strCandidate.typ.skipTypes(abstractInst).kind == tyString:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, strCandidate, a)
linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
@@ -818,14 +823,14 @@ proc cow(p: BProc; n: PNode) {.inline.} =
proc genAddr(p: BProc, e: PNode, d: var TLoc) =
# careful 'addr(myptrToArray)' needs to get the ampersand:
if e[0].typ.skipTypes(abstractInstOwned).kind in {tyRef, tyPtr}:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[0], a)
putIntoDest(p, d, e, "&" & a.r, a.storage)
#Message(e.info, warnUser, "HERE NEW &")
elif mapType(p.config, e[0].typ, mapTypeChooser(e[0]) == skParam) == ctArray or isCppRef(p, e.typ):
expr(p, e[0], d)
else:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[0], a)
putIntoDest(p, d, e, addrLoc(p.config, a), a.storage)
@@ -840,8 +845,8 @@ proc genRecordFieldAux(p: BProc, e: PNode, d, a: var TLoc) =
proc genTupleElem(p: BProc, e: PNode, d: var TLoc) =
var
a: TLoc
i: int
a: TLoc = default(TLoc)
i: int = 0
initLocExpr(p, e[0], a)
let tupType = a.t.skipTypes(abstractInst+{tyVar})
assert tupType.kind == tyTuple
@@ -856,6 +861,7 @@ proc genTupleElem(p: BProc, e: PNode, d: var TLoc) =
proc lookupFieldAgain(p: BProc, ty: PType; field: PSym; r: var Rope;
resTyp: ptr PType = nil): PSym =
result = nil
var ty = ty
assert r != ""
while ty != nil:
@@ -870,7 +876,7 @@ proc lookupFieldAgain(p: BProc, ty: PType; field: PSym; r: var Rope;
if result == nil: internalError(p.config, field.info, "genCheckedRecordField")
proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
genRecordFieldAux(p, e, d, a)
var r = rdLoc(a)
var f = e[1].sym
@@ -882,7 +888,7 @@ proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
r.add rope(f.position)
putIntoDest(p, d, e, r, a.storage)
else:
var rtyp: PType
var rtyp: PType = nil
let field = lookupFieldAgain(p, ty, f, r, addr rtyp)
if field.loc.r == "" and rtyp != nil: fillObjectFields(p.module, rtyp)
if field.loc.r == "": internalError(p.config, e.info, "genRecordField 3 " & typeToString(ty))
@@ -894,7 +900,7 @@ proc genRecordField(p: BProc, e: PNode, d: var TLoc) =
proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc)
proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
var test, u, v: TLoc
var test, u, v: TLoc = default(TLoc)
for i in 1..<e.len:
var it = e[i]
assert(it.kind in nkCallKinds)
@@ -938,7 +944,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
let toStrProc = getToStringProc(p.module.g.graph, base)
# XXX need to modify this logic for IC.
# need to analyze nkFieldCheckedExpr and marks procs "used" like range checks in dce
var toStr: TLoc
var toStr: TLoc = default(TLoc)
expr(p, newSymNode(toStrProc), toStr)
let enumStr = "$1($2)" % [rdLoc(toStr), rdLoc(v)]
linefmt(p, cpsStmts, code, [strLit, enumStr])
@@ -961,7 +967,7 @@ proc genFieldCheck(p: BProc, e: PNode, obj: Rope, field: PSym) =
proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
assert e[0].kind == nkDotExpr
if optFieldCheck in p.options:
var a: TLoc
var a: TLoc = default(TLoc)
genRecordFieldAux(p, e[0], d, a)
let ty = skipTypes(a.t, abstractInst + tyUserTypeClasses)
var r = rdLoc(a)
@@ -979,7 +985,7 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
genRecordField(p, e[0], d)
proc genUncheckedArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, x, a)
initLocExpr(p, y, b)
d.inheritLocation(a)
@@ -987,7 +993,7 @@ proc genUncheckedArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
a.storage)
proc genArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, x, a)
initLocExpr(p, y, b)
var ty = skipTypes(a.t, abstractVarRange + abstractPtrs + tyUserTypeClasses)
@@ -1022,7 +1028,7 @@ proc genArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
ropecg(p.module, "$1[($2)- $3]", [rdLoc(a), rdCharLoc(b), first]), a.storage)
proc genCStringElem(p: BProc, n, x, y: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, x, a)
initLocExpr(p, y, b)
inheritLocation(d, a)
@@ -1070,7 +1076,7 @@ proc genBoundsCheck(p: BProc; arr, a, b: TLoc) =
else: discard
proc genOpenArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, x, a)
initLocExpr(p, y, b)
if not reifiedOpenArray(x):
@@ -1096,7 +1102,7 @@ proc genOpenArrayElem(p: BProc, n, x, y: PNode, d: var TLoc) =
ropecg(p.module, "$1.Field0[$2]", [rdLoc(a), rdCharLoc(b)]), a.storage)
proc genSeqElem(p: BProc, n, x, y: PNode, d: var TLoc) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, x, a)
initLocExpr(p, y, b)
var ty = skipTypes(a.t, abstractVarRange)
@@ -1148,6 +1154,8 @@ proc isSimpleExpr(n: PNode): bool =
else:
if n.isAtom:
result = true
else:
result = false
proc genAndOr(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
# how to generate code?
@@ -1189,7 +1197,7 @@ proc genAndOr(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
else:
var
L: TLabel
tmp: TLoc
tmp: TLoc = default(TLoc)
getTemp(p, e.typ, tmp) # force it into a temp!
inc p.splitDecls
expr(p, e[1], tmp)
@@ -1213,7 +1221,7 @@ proc genEcho(p: BProc, n: PNode) =
if p.config.target.targetOS == osGenode:
# echo directly to the Genode LOG session
var args: Rope = ""
var a: TLoc
var a: TLoc = default(TLoc)
for i, it in n.sons:
if it.skipConv.kind == nkNilLit:
args.add(", \"\"")
@@ -1233,7 +1241,7 @@ proc genEcho(p: BProc, n: PNode) =
if n.len == 0:
linefmt(p, cpsStmts, "#echoBinSafe(NIM_NIL, $1);$n", [n.len])
else:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n, a)
linefmt(p, cpsStmts, "#echoBinSafe($1, $2);$n", [a.rdLoc, n.len])
when false:
@@ -1268,7 +1276,7 @@ proc genStrConcat(p: BProc, e: PNode, d: var TLoc) =
# appendChar(tmp0, 'z');
# asgn(s, tmp0);
# }
var a, tmp: TLoc
var a, tmp: TLoc = default(TLoc)
getTemp(p, e.typ, tmp)
var L = 0
var appends: Rope = ""
@@ -1307,8 +1315,8 @@ proc genStrAppend(p: BProc, e: PNode, d: var TLoc) =
# appendChar(s, 'z');
# }
var
a, dest, call: TLoc
appends, lens: Rope
a, dest, call: TLoc = default(TLoc)
appends, lens: Rope = ""
assert(d.k == locNone)
var L = 0
initLocExpr(p, e[1], dest)
@@ -1341,7 +1349,7 @@ proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) =
# seq &= x -->
# seq = (typeof seq) incrSeq(&seq->Sup, sizeof(x));
# seq->data[seq->len-1] = x;
var a, b, dest, tmpL, call: TLoc
var a, b, dest, tmpL, call: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
let seqType = skipTypes(e[1].typ, {tyVar})
@@ -1369,7 +1377,7 @@ proc genSeqElemAppend(p: BProc, e: PNode, d: var TLoc) =
gcUsage(p.config, e)
proc genReset(p: BProc, n: PNode) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[1], a)
specializeReset(p, a)
when false:
@@ -1384,7 +1392,7 @@ proc genDefault(p: BProc; n: PNode; d: var TLoc) =
proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
var sizeExpr = sizeExpr
let typ = a.t
var b: TLoc
var b: TLoc = default(TLoc)
initLoc(b, locExpr, a.lode, OnHeap)
let refType = typ.skipTypes(abstractInstOwned)
assert refType.kind == tyRef
@@ -1411,7 +1419,7 @@ proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
localError(p.module.config, a.lode.info,
"the destructor that is turned into a finalizer needs " &
"to have the 'nimcall' calling convention")
var f: TLoc
var f: TLoc = default(TLoc)
initLocExpr(p, newSymNode(op), f)
p.module.s[cfsTypeInit3].addf("$1->finalizer = (void*)$2;$n", [ti, rdLoc(f)])
@@ -1437,11 +1445,11 @@ proc rawGenNew(p: BProc, a: var TLoc, sizeExpr: Rope; needsInit: bool) =
genObjectInit(p, cpsStmts, bt, a, constructRefObj)
proc genNew(p: BProc, e: PNode) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
# 'genNew' also handles 'unsafeNew':
if e.len == 3:
var se: TLoc
var se: TLoc = default(TLoc)
initLocExpr(p, e[2], se)
rawGenNew(p, a, se.rdLoc, needsInit = true)
else:
@@ -1450,7 +1458,7 @@ proc genNew(p: BProc, e: PNode) =
proc genNewSeqAux(p: BProc, dest: TLoc, length: Rope; lenIsZero: bool) =
let seqtype = skipTypes(dest.t, abstractVarRange)
var call: TLoc
var call: TLoc = default(TLoc)
initLoc(call, locExpr, dest.lode, OnHeap)
if dest.storage == OnHeap and usesWriteBarrier(p.config):
if canFormAcycle(p.module.g.graph, dest.t):
@@ -1476,7 +1484,7 @@ proc genNewSeqAux(p: BProc, dest: TLoc, length: Rope; lenIsZero: bool) =
genAssignment(p, dest, call, {})
proc genNewSeq(p: BProc, e: PNode) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
if optSeqDestructors in p.config.globalOptions:
@@ -1492,7 +1500,7 @@ proc genNewSeq(p: BProc, e: PNode) =
proc genNewSeqOfCap(p: BProc; e: PNode; d: var TLoc) =
let seqtype = skipTypes(e.typ, abstractVarRange)
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
if optSeqDestructors in p.config.globalOptions:
if d.k == locNone: getTemp(p, e.typ, d, needsInit=false)
@@ -1548,7 +1556,7 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
(d.k notin {locTemp,locLocalVar,locGlobalVar,locParam,locField}) or
(isPartOf(d.lode, e) != arNo)
var tmp: TLoc
var tmp: TLoc = default(TLoc)
var r: Rope
if useTemp:
getTemp(p, t, tmp)
@@ -1567,7 +1575,7 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
let ty = getUniqueType(t)
for i in 1..<e.len:
let it = e[i]
var tmp2: TLoc
var tmp2: TLoc = default(TLoc)
tmp2.r = r
let field = lookupFieldAgain(p, ty, it[0].sym, tmp2.r)
if field.loc.r == "": fillObjectFields(p.module, ty)
@@ -1591,11 +1599,12 @@ proc genObjConstr(p: BProc, e: PNode, d: var TLoc) =
genAssignment(p, d, tmp, {})
proc lhsDoesAlias(a, b: PNode): bool =
result = false
for y in b:
if isPartOf(a, y) != arNo: return true
proc genSeqConstr(p: BProc, n: PNode, d: var TLoc) =
var arr, tmp: TLoc
var arr, tmp: TLoc = default(TLoc)
# bug #668
let doesAlias = lhsDoesAlias(d.lode, n)
let dest = if doesAlias: addr(tmp) else: addr(d)
@@ -1629,7 +1638,7 @@ proc genSeqConstr(p: BProc, n: PNode, d: var TLoc) =
genAssignment(p, d, tmp, {})
proc genArrToSeq(p: BProc, n: PNode, d: var TLoc) =
var elem, a, arr: TLoc
var elem, a, arr: TLoc = default(TLoc)
if n[1].kind == nkBracket:
n[1].typ = n.typ
genSeqConstr(p, n[1], d)
@@ -1660,7 +1669,7 @@ proc genArrToSeq(p: BProc, n: PNode, d: var TLoc) =
arr.r = ropecg(p.module, "$1[$2]", [rdLoc(a), lit])
genAssignment(p, elem, arr, {needToCopy})
else:
var i: TLoc
var i: TLoc = default(TLoc)
getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt), i)
linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n", [i.r, L])
initLoc(elem, locExpr, lodeTyp elemType(skipTypes(n.typ, abstractInst)), OnHeap)
@@ -1674,7 +1683,7 @@ proc genArrToSeq(p: BProc, n: PNode, d: var TLoc) =
proc genNewFinalize(p: BProc, e: PNode) =
var
a, b, f: TLoc
a, b, f: TLoc = default(TLoc)
refType, bt: PType
ti: Rope
refType = skipTypes(e[1].typ, abstractVarRange)
@@ -1710,7 +1719,7 @@ proc genOfHelper(p: BProc; dest: PType; a: Rope; info: TLineInfo; result: var Ro
appcg(p.module, result, "#isObjWithCache($#.m_type, $#, $#)", [a, ti, cache])
proc genOf(p: BProc, x: PNode, typ: PType, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, x, a)
var dest = skipTypes(typ, typedescPtrs)
var r = rdLoc(a)
@@ -1752,7 +1761,7 @@ proc genOf(p: BProc, n: PNode, d: var TLoc) =
proc genRepr(p: BProc, e: PNode, d: var TLoc) =
if optTinyRtti in p.config.globalOptions:
localError(p.config, e.info, "'repr' is not available for --newruntime")
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
var t = skipTypes(e[1].typ, abstractVarRange)
case t.kind
@@ -1775,7 +1784,7 @@ proc genRepr(p: BProc, e: PNode, d: var TLoc) =
putIntoDest(p, d, e, ropecg(p.module, "#reprSet($1, $2)", [
addrLoc(p.config, a), genTypeInfoV1(p.module, t, e.info)]), a.storage)
of tyOpenArray, tyVarargs:
var b: TLoc
var b: TLoc = default(TLoc)
case skipTypes(a.t, abstractVarRange).kind
of tyOpenArray, tyVarargs:
putIntoDest(p, b, e, "$1, $1Len_0" % [rdLoc(a)], a.storage)
@@ -1833,7 +1842,7 @@ proc genGetTypeInfoV2(p: BProc, e: PNode, d: var TLoc) =
# ordinary static type information
putIntoDest(p, d, e, genTypeInfoV2(p.module, t, e.info))
else:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
var nilCheck = ""
# use the dynamic type stored at offset 0:
@@ -1842,7 +1851,7 @@ proc genGetTypeInfoV2(p: BProc, e: PNode, d: var TLoc) =
putIntoDest(p, d, e, rt)
proc genAccessTypeField(p: BProc; e: PNode; d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
var nilCheck = ""
# use the dynamic type stored at offset 0:
@@ -1851,7 +1860,7 @@ proc genAccessTypeField(p: BProc; e: PNode; d: var TLoc) =
putIntoDest(p, d, e, rt)
template genDollar(p: BProc, n: PNode, d: var TLoc, frmt: string) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[1], a)
a.r = ropecg(p.module, frmt, [rdLoc(a)])
a.flags.excl lfIndirect # this flag should not be propagated here (not just for HCR)
@@ -1868,8 +1877,8 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
# Bug #9279, len(toOpenArray()) has to work:
if a.kind in nkCallKinds and a[0].kind == nkSym and a[0].sym.magic == mSlice:
# magic: pass slice to openArray:
var m: TLoc
var b, c: TLoc
var m: TLoc = default(TLoc)
var b, c: TLoc = default(TLoc)
initLocExpr(p, a[1], m)
initLocExpr(p, a[2], b)
initLocExpr(p, a[3], c)
@@ -1899,14 +1908,14 @@ proc genArrayLen(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
if op == mHigh: unaryExpr(p, e, d, "($1 ? (#nimCStrLen($1)-1) : -1)")
else: unaryExpr(p, e, d, "($1 ? #nimCStrLen($1) : 0)")
of tyString:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
var x = lenExpr(p, a)
if op == mHigh: x = "($1-1)" % [x]
putIntoDest(p, d, e, x)
of tySequence:
# we go through a temporary here because people write bullshit code.
var a, tmp: TLoc
var a, tmp: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
getIntTemp(p, tmp)
var x = lenExpr(p, a)
@@ -1931,7 +1940,7 @@ proc genSetLengthSeq(p: BProc, e: PNode, d: var TLoc) =
e[1] = makeAddr(e[1], p.module.idgen)
genCall(p, e, d)
return
var a, b, call: TLoc
var a, b, call: TLoc = default(TLoc)
assert(d.k == locNone)
var x = e[1]
if x.kind in {nkAddr, nkHiddenAddr}: x = x[0]
@@ -1959,7 +1968,7 @@ proc genSetLengthStr(p: BProc, e: PNode, d: var TLoc) =
if optSeqDestructors in p.config.globalOptions:
binaryStmtAddr(p, e, d, "setLengthStrV2")
else:
var a, b, call: TLoc
var a, b, call: TLoc = default(TLoc)
if d.k != locNone: internalError(p.config, e.info, "genSetLengthStr")
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
@@ -1977,7 +1986,7 @@ proc genSwap(p: BProc, e: PNode, d: var TLoc) =
# b = temp
cowBracket(p, e[1])
cowBracket(p, e[2])
var a, b, tmp: TLoc
var a, b, tmp: TLoc = default(TLoc)
getTemp(p, skipTypes(e[1].typ, abstractVar), tmp)
initLocExpr(p, e[1], a) # eval a
initLocExpr(p, e[2], b) # eval b
@@ -2022,7 +2031,7 @@ proc genInExprAux(p: BProc, e: PNode, a, b, d: var TLoc) =
else: binaryExprIn(p, e, a, b, d, "(($1[(NU)($2)>>3] &(1U<<((NU)($2)&7U)))!=0)")
template binaryStmtInExcl(p: BProc, e: PNode, d: var TLoc, frmt: string) =
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(d.k == locNone)
initLocExpr(p, e[1], a)
initLocExpr(p, e[2], b)
@@ -2031,7 +2040,7 @@ template binaryStmtInExcl(p: BProc, e: PNode, d: var TLoc, frmt: string) =
lineF(p, cpsStmts, frmt, [rdLoc(a), elem])
proc genInOp(p: BProc, e: PNode, d: var TLoc) =
var a, b, x, y: TLoc
var a, b, x, y: TLoc = default(TLoc)
if (e[1].kind == nkCurly) and fewCmps(p.config, e[1]):
# a set constructor but not a constant set:
# do not emit the set, but generate a bunch of comparisons; and if we do
@@ -2081,7 +2090,7 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
"&",
"|",
"& ~"]
var a, b, i: TLoc
var a, b, i: TLoc = default(TLoc)
var setType = skipTypes(e[1].typ, abstractVar)
var size = int(getSize(p.config, setType))
case size
@@ -2118,7 +2127,7 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
of mIncl: binaryStmtInExcl(p, e, d, "$1[(NU)($2)>>3] |=(1U<<($2&7U));$n")
of mExcl: binaryStmtInExcl(p, e, d, "$1[(NU)($2)>>3] &= ~(1U<<($2&7U));$n")
of mCard:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
putIntoDest(p, d, e, ropecg(p.module, "#cardSet($1, $2)", [addrLoc(p.config, a), size]))
of mLtSet, mLeSet:
@@ -2133,7 +2142,7 @@ proc genSetOp(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
linefmt(p, cpsStmts, lookupOpr[mLeSet],
[rdLoc(i), size, rdLoc(d), rdLoc(a), rdLoc(b)])
of mEqSet:
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -2161,7 +2170,7 @@ proc genSomeCast(p: BProc, e: PNode, d: var TLoc) =
ValueTypes = {tyTuple, tyObject, tyArray, tyOpenArray, tyVarargs, tyUncheckedArray}
# we use whatever C gives us. Except if we have a value-type, we need to go
# through its address:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
let etyp = skipTypes(e.typ, abstractRange+{tyOwned})
let srcTyp = skipTypes(e[1].typ, abstractRange)
@@ -2199,7 +2208,7 @@ proc genCast(p: BProc, e: PNode, d: var TLoc) =
# 'cast' and some float type involved? --> use a union.
inc(p.labels)
var lbl = p.labels.rope
var tmp: TLoc
var tmp: TLoc = default(TLoc)
tmp.r = "LOC$1.source" % [lbl]
let destsize = getSize(p.config, destt)
let srcsize = getSize(p.config, srct)
@@ -2222,7 +2231,7 @@ proc genCast(p: BProc, e: PNode, d: var TLoc) =
genSomeCast(p, e, d)
proc genRangeChck(p: BProc, n: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
var dest = skipTypes(n.typ, abstractVar)
initLocExpr(p, n[0], a)
if optRangeCheck notin p.options or (dest.kind in {tyUInt..tyUInt64} and
@@ -2277,7 +2286,7 @@ proc genConv(p: BProc, e: PNode, d: var TLoc) =
genSomeCast(p, e, d)
proc convStrToCStr(p: BProc, n: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
putIntoDest(p, d, n,
ropecg(p.module, "#nimToCStringConv($1)", [rdLoc(a)]),
@@ -2285,7 +2294,7 @@ proc convStrToCStr(p: BProc, n: PNode, d: var TLoc) =
a.storage)
proc convCStrToStr(p: BProc, n: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
putIntoDest(p, d, n,
ropecg(p.module, "#cstrToNimstr($1)", [rdLoc(a)]),
@@ -2293,7 +2302,7 @@ proc convCStrToStr(p: BProc, n: PNode, d: var TLoc) =
gcUsage(p.config, n)
proc genStrEquals(p: BProc, e: PNode, d: var TLoc) =
var x: TLoc
var x: TLoc = default(TLoc)
var a = e[1]
var b = e[2]
if a.kind in {nkStrLit..nkTripleStrLit} and a.strVal == "":
@@ -2310,7 +2319,7 @@ proc genStrEquals(p: BProc, e: PNode, d: var TLoc) =
proc binaryFloatArith(p: BProc, e: PNode, d: var TLoc, m: TMagic) =
if {optNaNCheck, optInfCheck} * p.options != {}:
const opr: array[mAddF64..mDivF64, string] = ["+", "-", "*", "/"]
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -2335,7 +2344,7 @@ proc skipAddr(n: PNode): PNode =
result = if n.kind in {nkAddr, nkHiddenAddr}: n[0] else: n
proc genWasMoved(p: BProc; n: PNode) =
var a: TLoc
var a: TLoc = default(TLoc)
let n1 = n[1].skipAddr
if p.withinBlockLeaveActions > 0 and notYetAlive(n1):
discard
@@ -2346,11 +2355,11 @@ proc genWasMoved(p: BProc; n: PNode) =
# [addrLoc(p.config, a), getTypeDesc(p.module, a.t)])
proc genMove(p: BProc; n: PNode; d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[1].skipAddr, a)
if n.len == 4:
# generated by liftdestructors:
var src: TLoc
var src: TLoc = default(TLoc)
initLocExpr(p, n[2], src)
linefmt(p, cpsStmts, "if ($1.p != $2.p) {", [rdLoc(a), rdLoc(src)])
genStmts(p, n[3])
@@ -2377,7 +2386,7 @@ proc genDestroy(p: BProc; n: PNode) =
let t = arg.typ.skipTypes(abstractInst)
case t.kind
of tyString:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, arg, a)
if optThreads in p.config.globalOptions:
linefmt(p, cpsStmts, "if ($1.p && !($1.p->cap & NIM_STRLIT_FLAG)) {$n" &
@@ -2388,7 +2397,7 @@ proc genDestroy(p: BProc; n: PNode) =
" #dealloc($1.p);$n" &
"}$n", [rdLoc(a)])
of tySequence:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, arg, a)
linefmt(p, cpsStmts, "if ($1.p && !($1.p->cap & NIM_STRLIT_FLAG)) {$n" &
" #alignedDealloc($1.p, NIM_ALIGNOF($2));$n" &
@@ -2406,7 +2415,7 @@ proc genDispose(p: BProc; n: PNode) =
when false:
let elemType = n[1].typ.skipTypes(abstractVar).lastSon
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[1].skipAddr, a)
if isFinal(elemType):
@@ -2459,7 +2468,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
if optOverflowCheck notin p.options or underlying.kind in {tyUInt..tyUInt64}:
binaryStmt(p, e, d, opr[op])
else:
var a, b: TLoc
var a, b: TLoc = default(TLoc)
assert(e[1].typ != nil)
assert(e[2].typ != nil)
initLocExpr(p, e[1], a)
@@ -2477,7 +2486,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
if optSeqDestructors in p.config.globalOptions:
binaryStmtAddr(p, e, d, "nimAddCharV1")
else:
var dest, b, call: TLoc
var dest, b, call: TLoc = default(TLoc)
initLoc(call, locCall, e, OnHeap)
initLocExpr(p, e[1], dest)
initLocExpr(p, e[2], b)
@@ -2515,7 +2524,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
of mNew: genNew(p, e)
of mNewFinalize:
if optTinyRtti in p.config.globalOptions:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, e[1], a)
rawGenNew(p, a, "", needsInit = true)
gcUsage(p.config, e)
@@ -2541,6 +2550,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
elif e[1].kind == nkCheckedFieldExpr:
dotExpr = e[1][0]
else:
dotExpr = nil
internalError(p.config, e.info, "unknown ast")
let t = dotExpr[0].typ.skipTypes({tyTypeDesc})
let tname = getTypeDesc(p.module, t, dkVar)
@@ -2609,7 +2619,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
localError(p.config, e.info,
"for --gc:arc|orc 'deepcopy' support has to be enabled with --deepcopy:on")
var a, b: TLoc
var a, b: TLoc = default(TLoc)
let x = if e[1].kind in {nkAddr, nkHiddenAddr}: e[1][0] else: e[1]
initLocExpr(p, x, a)
initLocExpr(p, e[2], b)
@@ -2635,7 +2645,7 @@ proc genSetConstr(p: BProc, e: PNode, d: var TLoc) =
# nimZeroMem(tmp, sizeof(tmp)); inclRange(tmp, a, b); incl(tmp, c);
# incl(tmp, d); incl(tmp, e); inclRange(tmp, f, g);
var
a, b, idx: TLoc
a, b, idx: TLoc = default(TLoc)
if nfAllConst in e.flags:
var elem = newRopeAppender()
genSetNode(p, e, elem)
@@ -2690,12 +2700,12 @@ proc genSetConstr(p: BProc, e: PNode, d: var TLoc) =
[rdLoc(d), aa, rope(ts)])
proc genTupleConstr(p: BProc, n: PNode, d: var TLoc) =
var rec: TLoc
var rec: TLoc = default(TLoc)
if not handleConstExpr(p, n, d):
let t = n.typ
discard getTypeDesc(p.module, t) # so that any fields are initialized
var tmp: TLoc
var tmp: TLoc = default(TLoc)
# bug #16331
let doesAlias = lhsDoesAlias(d.lode, n)
let dest = if doesAlias: addr(tmp) else: addr(d)
@@ -2734,7 +2744,7 @@ proc genClosure(p: BProc, n: PNode, d: var TLoc) =
p.module.s[cfsData].add data
putIntoDest(p, d, n, tmp, OnStatic)
else:
var tmp, a, b: TLoc
var tmp, a, b: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
initLocExpr(p, n[1], b)
if n[0].skipConv.kind == nkClosure:
@@ -2751,7 +2761,7 @@ proc genClosure(p: BProc, n: PNode, d: var TLoc) =
putLocIntoDest(p, d, tmp)
proc genArrayConstr(p: BProc, n: PNode, d: var TLoc) =
var arr: TLoc
var arr: TLoc = default(TLoc)
if not handleConstExpr(p, n, d):
if d.k == locNone: getTemp(p, n.typ, d)
for i in 0..<n.len:
@@ -2799,7 +2809,7 @@ proc genStmtList(p: BProc, n: PNode) =
from parampatterns import isLValue
proc upConv(p: BProc, n: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
let dest = skipTypes(n.typ, abstractPtrs)
if optObjCheck in p.options and not isObjLackingTypeField(dest):
@@ -2851,7 +2861,7 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
# (see bug #837). However sometimes using a temporary is not correct:
# init(TFigure(my)) # where it is passed to a 'var TFigure'. We test
# this by ensuring the destination is also a pointer:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, arg, a)
putIntoDest(p, d, n,
"(*(($1*) (&($2))))" % [getTypeDesc(p.module, n.typ), rdLoc(a)], a.storage)
@@ -2859,7 +2869,7 @@ proc downConv(p: BProc, n: PNode, d: var TLoc) =
# C++ implicitly downcasts for us
expr(p, arg, d)
else:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, arg, a)
var r = rdLoc(a) & (if isRef: "->Sup" else: ".Sup")
for i in 2..abs(inheritanceDiff(dest, src)): r.add(".Sup")
@@ -3049,7 +3059,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
let op = n[0]
if n.typ.isNil:
# discard the value:
var a: TLoc
var a: TLoc = default(TLoc)
if op.kind == nkSym and op.sym.magic != mNone:
genMagicExpr(p, n, a, op.sym.magic)
else:
@@ -3143,7 +3153,7 @@ proc expr(p: BProc, n: PNode, d: var TLoc) =
let ex = n[0]
if ex.kind != nkEmpty:
genLineDir(p, n)
var a: TLoc
var a: TLoc = default(TLoc)
initLocExprSingleUse(p, ex, a)
line(p, cpsStmts, "(void)(" & a.r & ");\L")
of nkAsmStmt: genAsmStmt(p, n)
@@ -3254,6 +3264,7 @@ proc getDefaultValue(p: BProc; typ: PType; info: TLineInfo; result: var Rope) =
globalError(p.config, info, "cannot create null element for: " & $t.kind)
proc caseObjDefaultBranch(obj: PNode; branch: Int128): int =
result = 0
for i in 1 ..< obj.len:
for j in 0 .. obj[i].len - 2:
if obj[i][j].kind == nkRange:
@@ -3464,11 +3475,11 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
if n[0].kind == nkNilLit:
result.add "{NIM_NIL,NIM_NIL}"
else:
var d: TLoc
var d: TLoc = default(TLoc)
initLocExpr(p, n[0], d)
result.add "{(($1) $2),NIM_NIL}" % [getClosureType(p.module, typ, clHalfWithEnv), rdLoc(d)]
else:
var d: TLoc
var d: TLoc = default(TLoc)
initLocExpr(p, n, d)
result.add rdLoc(d)
of tyArray, tyVarargs:
@@ -3497,10 +3508,10 @@ proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; resul
if optSeqDestructors in p.config.globalOptions and n.kind != nkNilLit and ty == tyString:
genStringLiteralV2Const(p.module, n, isConst, result)
else:
var d: TLoc
var d: TLoc = default(TLoc)
initLocExpr(p, n, d)
result.add rdLoc(d)
else:
var d: TLoc
var d: TLoc = default(TLoc)
initLocExpr(p, n, d)
result.add rdLoc(d)

2
compiler/ccgreset.nim
View File

@@ -57,7 +57,7 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
specializeResetT(p, accessor, lastSon(typ))
of tyArray:
let arraySize = lengthOrd(p.config, typ[0])
var i: TLoc
var i: TLoc = default(TLoc)
getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt), i)
linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
[i.r, arraySize])

55
compiler/ccgstmts.nim
View File

@@ -50,6 +50,7 @@ proc isAssignedImmediately(conf: ConfigRef; n: PNode): bool {.inline.} =
result = true
proc inExceptBlockLen(p: BProc): int =
result = 0
for x in p.nestedTryStmts:
if x.inExcept: result.inc
@@ -71,7 +72,7 @@ template startBlock(p: BProc, start: FormatStr = "{$n",
proc endBlock(p: BProc)
proc genVarTuple(p: BProc, n: PNode) =
var tup, field: TLoc
var tup, field: TLoc = default(TLoc)
if n.kind != nkVarTuple: internalError(p.config, n.info, "genVarTuple")
# if we have a something that's been captured, use the lowering instead:
@@ -83,7 +84,7 @@ proc genVarTuple(p: BProc, n: PNode) =
# check only the first son
var forHcr = treatGlobalDifferentlyForHCR(p.module, n[0].sym)
let hcrCond = if forHcr: getTempName(p.module) else: ""
var hcrGlobals: seq[tuple[loc: TLoc, tp: Rope]]
var hcrGlobals: seq[tuple[loc: TLoc, tp: Rope]] = @[]
# determine if the tuple is constructed at top-level scope or inside of a block (if/while/block)
let isGlobalInBlock = forHcr and p.blocks.len > 2
# do not close and reopen blocks if this is a 'global' but inside of a block (if/while/block)
@@ -169,7 +170,7 @@ proc endBlock(p: BProc, blockEnd: Rope) =
proc endBlock(p: BProc) =
let topBlock = p.blocks.len - 1
let frameLen = p.blocks[topBlock].frameLen
var blockEnd: Rope
var blockEnd: Rope = ""
if frameLen > 0:
blockEnd.addf("FR_.len-=$1;$n", [frameLen.rope])
if p.blocks[topBlock].label.len != 0:
@@ -244,7 +245,7 @@ proc genGotoState(p: BProc, n: PNode) =
# switch (x.state) {
# case 0: goto STATE0;
# ...
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
lineF(p, cpsStmts, "switch ($1) {$n", [rdLoc(a)])
p.flags.incl beforeRetNeeded
@@ -263,7 +264,7 @@ proc genGotoState(p: BProc, n: PNode) =
lineF(p, cpsStmts, "}$n", [])
proc genBreakState(p: BProc, n: PNode, d: var TLoc) =
var a: TLoc
var a: TLoc = default(TLoc)
initLoc(d, locExpr, n, OnUnknown)
if n[0].kind == nkClosure:
@@ -357,7 +358,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
# generate better code here: 'Foo f = x;'
genLineDir(p, vn)
var decl = localVarDecl(p, vn)
var tmp: TLoc
var tmp: TLoc = default(TLoc)
if isCppCtorCall:
genCppVarForCtor(p, v, vn, value, decl)
line(p, cpsStmts, decl)
@@ -441,7 +442,7 @@ proc genIf(p: BProc, n: PNode, d: var TLoc) =
# { elsePart }
# Lend:
var
a: TLoc
a: TLoc = default(TLoc)
lelse: TLabel
if not isEmptyType(n.typ) and d.k == locNone:
getTemp(p, n.typ, d)
@@ -520,7 +521,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
# wrapped inside stmt lists by inject destructors won't be recognised
let n = n.flattenStmts()
var casePos = -1
var arraySize: int
var arraySize: int = 0
for i in 0..<n.len:
let it = n[i]
if it.kind == nkCaseStmt:
@@ -554,7 +555,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
genStmts(p, n[j])
let caseStmt = n[casePos]
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, caseStmt[0], a)
# first goto:
lineF(p, cpsStmts, "goto *$#[$#];$n", [tmp, a.rdLoc])
@@ -593,7 +594,7 @@ proc genComputedGoto(p: BProc; n: PNode) =
else:
genStmts(p, it)
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, caseStmt[0], a)
lineF(p, cpsStmts, "goto *$#[$#];$n", [tmp, a.rdLoc])
endBlock(p)
@@ -606,7 +607,7 @@ proc genWhileStmt(p: BProc, t: PNode) =
# we don't generate labels here as for example GCC would produce
# significantly worse code
var
a: TLoc
a: TLoc = default(TLoc)
assert(t.len == 2)
inc(p.withinLoop)
genLineDir(p, t)
@@ -661,7 +662,7 @@ proc genParForStmt(p: BProc, t: PNode) =
preserveBreakIdx:
let forLoopVar = t[0].sym
var rangeA, rangeB: TLoc
var rangeA, rangeB: TLoc = default(TLoc)
assignLocalVar(p, t[0])
#initLoc(forLoopVar.loc, locLocalVar, forLoopVar.typ, onStack)
#discard mangleName(forLoopVar)
@@ -685,7 +686,7 @@ proc genParForStmt(p: BProc, t: PNode) =
rangeA.rdLoc, rangeB.rdLoc,
call[3].getStr.rope])
else: # `||`(a, b, step, annotation)
var step: TLoc
var step: TLoc = default(TLoc)
initLocExpr(p, call[3], step)
lineF(p, cpsStmts, "$n#pragma omp $5$n" &
"for ($1 = $2; $1 <= $3; $1 += $4)",
@@ -756,7 +757,7 @@ proc raiseInstr(p: BProc; result: var Rope) =
proc genRaiseStmt(p: BProc, t: PNode) =
if t[0].kind != nkEmpty:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExprSingleUse(p, t[0], a)
finallyActions(p)
var e = rdLoc(a)
@@ -784,7 +785,7 @@ proc genRaiseStmt(p: BProc, t: PNode) =
template genCaseGenericBranch(p: BProc, b: PNode, e: TLoc,
rangeFormat, eqFormat: FormatStr, labl: TLabel) =
var x, y: TLoc
var x, y: TLoc = default(TLoc)
for i in 0..<b.len - 1:
if b[i].kind == nkRange:
initLocExpr(p, b[i][0], x)
@@ -834,7 +835,7 @@ template genIfForCaseUntil(p: BProc, t: PNode, d: var TLoc,
template genCaseGeneric(p: BProc, t: PNode, d: var TLoc,
rangeFormat, eqFormat: FormatStr) =
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, t[0], a)
var lend = genIfForCaseUntil(p, t, d, rangeFormat, eqFormat, t.len-1, a)
fixLabel(p, lend)
@@ -842,11 +843,11 @@ template genCaseGeneric(p: BProc, t: PNode, d: var TLoc,
proc genCaseStringBranch(p: BProc, b: PNode, e: TLoc, labl: TLabel,
stringKind: TTypeKind,
branches: var openArray[Rope]) =
var x: TLoc
var x: TLoc = default(TLoc)
for i in 0..<b.len - 1:
assert(b[i].kind != nkRange)
initLocExpr(p, b[i], x)
var j: int
var j: int = 0
case b[i].kind
of nkStrLit..nkTripleStrLit:
j = int(hashString(p.config, b[i].strVal) and high(branches))
@@ -869,7 +870,7 @@ proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
var bitMask = math.nextPowerOfTwo(strings) - 1
var branches: seq[Rope]
newSeq(branches, bitMask + 1)
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, t[0], a) # fist pass: generate ifs+goto:
var labId = p.labels
for i in 1..<t.len:
@@ -906,6 +907,7 @@ proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
genCaseGeneric(p, t, d, "", "if (#eqStrings($1, $2)) goto $3;$n")
proc branchHasTooBigRange(b: PNode): bool =
result = false
for it in b:
# last son is block
if (it.kind == nkRange) and
@@ -913,6 +915,7 @@ proc branchHasTooBigRange(b: PNode): bool =
return true
proc ifSwitchSplitPoint(p: BProc, n: PNode): int =
result = 0
for i in 1..<n.len:
var branch = n[i]
var stmtBlock = lastSon(branch)
@@ -948,7 +951,7 @@ proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
var splitPoint = ifSwitchSplitPoint(p, n)
# generate if part (might be empty):
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, n[0], a)
var lend = if splitPoint > 0: genIfForCaseUntil(p, n, d,
rangeFormat = "if ($1 >= $2 && $1 <= $3) goto $4;$n",
@@ -1389,7 +1392,7 @@ proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
p.flags.incl noSafePoints
genLineDir(p, t)
cgsym(p.module, "Exception")
var safePoint: Rope
var safePoint: Rope = ""
if not quirkyExceptions:
safePoint = getTempName(p.module)
linefmt(p, cpsLocals, "#TSafePoint $1;$n", [safePoint])
@@ -1492,7 +1495,7 @@ proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false; result: var Rope) =
of nkSym:
var sym = it.sym
if sym.kind in {skProc, skFunc, skIterator, skMethod}:
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, it, a)
res.add($rdLoc(a))
elif sym.kind == skType:
@@ -1505,7 +1508,7 @@ proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false; result: var Rope) =
res.add($getTypeDesc(p.module, it.typ))
else:
discard getTypeDesc(p.module, skipTypes(it.typ, abstractPtrs))
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(p, it, a)
res.add($a.rdLoc)
@@ -1608,7 +1611,7 @@ when false:
expr(p, call, d)
proc asgnFieldDiscriminant(p: BProc, e: PNode) =
var a, tmp: TLoc
var a, tmp: TLoc = default(TLoc)
var dotExpr = e[0]
if dotExpr.kind == nkCheckedFieldExpr: dotExpr = dotExpr[0]
initLocExpr(p, e[0], a)
@@ -1630,7 +1633,7 @@ proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) =
else:
let le = e[0]
let ri = e[1]
var a: TLoc
var a: TLoc = default(TLoc)
discard getTypeDesc(p.module, le.typ.skipTypes(skipPtrs), dkVar)
initLoc(a, locNone, le, OnUnknown)
a.flags.incl(lfEnforceDeref)
@@ -1644,7 +1647,7 @@ proc genAsgn(p: BProc, e: PNode, fastAsgn: bool) =
loadInto(p, le, ri, a)
proc genStmts(p: BProc, t: PNode) =
var a: TLoc
var a: TLoc = default(TLoc)
let isPush = p.config.hasHint(hintExtendedContext)
if isPush: pushInfoContext(p.config, t.info)

6
compiler/ccgtrav.nim
View File

@@ -74,7 +74,7 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
genTraverseProc(c, accessor, lastSon(typ))
of tyArray:
let arraySize = lengthOrd(c.p.config, typ[0])
var i: TLoc
var i: TLoc = default(TLoc)
getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt), i)
var oldCode = p.s(cpsStmts)
freeze oldCode
@@ -119,11 +119,11 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
proc genTraverseProcSeq(c: TTraversalClosure, accessor: Rope, typ: PType) =
var p = c.p
assert typ.kind == tySequence
var i: TLoc
var i: TLoc = default(TLoc)
getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt), i)
var oldCode = p.s(cpsStmts)
freeze oldCode
var a: TLoc
var a: TLoc = default(TLoc)
a.r = accessor
lineF(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",

45
compiler/ccgtypes.nim
View File

@@ -206,8 +206,12 @@ proc mapType(conf: ConfigRef; typ: PType; isParam: bool): TCTypeKind =
result = TCTypeKind(ord(typ.kind) - ord(tyInt) + ord(ctInt))
of tyStatic:
if typ.n != nil: result = mapType(conf, lastSon typ, isParam)
else: doAssert(false, "mapType: " & $typ.kind)
else: doAssert(false, "mapType: " & $typ.kind)
else:
result = ctVoid
doAssert(false, "mapType: " & $typ.kind)
else:
result = ctVoid
doAssert(false, "mapType: " & $typ.kind)
proc mapReturnType(conf: ConfigRef; typ: PType): TCTypeKind =
@@ -322,7 +326,9 @@ proc getSimpleTypeDesc(m: BModule; typ: PType): Rope =
of tyDistinct, tyRange, tyOrdinal: result = getSimpleTypeDesc(m, typ[0])
of tyStatic:
if typ.n != nil: result = getSimpleTypeDesc(m, lastSon typ)
else: internalError(m.config, "tyStatic for getSimpleTypeDesc")
else:
result = ""
internalError(m.config, "tyStatic for getSimpleTypeDesc")
of tyGenericInst, tyAlias, tySink, tyOwned:
result = getSimpleTypeDesc(m, lastSon typ)
else: result = ""
@@ -501,8 +507,8 @@ proc genMemberProcParams(m: BModule; prc: PSym, superCall, rettype, params: var
rettype = getTypeDescAux(m, t[0], check, dkResult)
else:
rettype = runtimeFormat(rettype.replace("'0", "$1"), [getTypeDescAux(m, t[0], check, dkResult)])
var types, names, args: seq[string]
if not isCtor:
var types, names, args: seq[string] = @[]
if not isCtor:
var this = t.n[1].sym
fillParamName(m, this)
fillLoc(this.loc, locParam, t.n[1],
@@ -719,9 +725,9 @@ proc getRecordFields(m: BModule; typ: PType, check: var IntSet): Rope =
genRecordFieldsAux(m, typ.n, typ, check, result)
if typ.itemId in m.g.graph.memberProcsPerType:
let procs = m.g.graph.memberProcsPerType[typ.itemId]
var isDefaultCtorGen, isCtorGen: bool
var isDefaultCtorGen, isCtorGen: bool = false
for prc in procs:
var header: Rope
var header: Rope = ""
if sfConstructor in prc.flags:
isCtorGen = true
if prc.typ.n.len == 1:
@@ -741,7 +747,8 @@ proc fillObjectFields*(m: BModule; typ: PType) =
proc mangleDynLibProc(sym: PSym): Rope
proc getRecordDescAux(m: BModule; typ: PType, name, baseType: Rope,
check: var IntSet, hasField:var bool): Rope =
check: var IntSet, hasField:var bool): Rope =
result = ""
if typ.kind == tyObject:
if typ[0] == nil:
if lacksMTypeField(typ):
@@ -782,7 +789,7 @@ proc getRecordDesc(m: BModule; typ: PType, name: Rope,
structOrUnion = "#pragma pack(push, 1)\L" & structOrUnion(typ)
else:
structOrUnion = structOrUnion(typ)
var baseType: string
var baseType: string = ""
if typ[0] != nil:
baseType = getTypeDescAux(m, typ[0].skipTypes(skipPtrs), check, dkField)
if typ.sym == nil or sfCodegenDecl notin typ.sym.flags:
@@ -873,6 +880,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
if t != origTyp and origTyp.sym != nil: useHeader(m, origTyp.sym)
let sig = hashType(origTyp, m.config)
result = "" # todo move `result = getTypePre(m, t, sig)` here ?
defer: # defer is the simplest in this case
if isImportedType(t) and not m.typeABICache.containsOrIncl(sig):
addAbiCheck(m, t, result)
@@ -953,7 +961,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
of tyProc:
result = getTypeName(m, origTyp, sig)
m.typeCache[sig] = result
var rettype, desc: Rope
var rettype, desc: Rope = ""
genProcParams(m, t, rettype, desc, check, true, true)
if not isImportedType(t):
if t.callConv != ccClosure: # procedure vars may need a closure!
@@ -1030,7 +1038,7 @@ proc getTypeDescAux(m: BModule; origTyp: PType, check: var IntSet; kind: TypeDes
while i < cppName.len:
if cppName[i] == '\'':
var chunkEnd = i-1
var idx, stars: int
var idx, stars: int = 0
if scanCppGenericSlot(cppName, i, idx, stars):
result.add cppName.substr(chunkStart, chunkEnd)
chunkStart = i
@@ -1110,7 +1118,7 @@ proc getClosureType(m: BModule; t: PType, kind: TClosureTypeKind): Rope =
assert t.kind == tyProc
var check = initIntSet()
result = getTempName(m)
var rettype, desc: Rope
var rettype, desc: Rope = ""
genProcParams(m, t, rettype, desc, check, declareEnvironment=kind != clHalf)
if not isImportedType(t):
if t.callConv != ccClosure or kind != clFull:
@@ -1141,7 +1149,7 @@ proc isNonReloadable(m: BModule; prc: PSym): bool =
return m.hcrOn and sfNonReloadable in prc.flags
proc parseVFunctionDecl(val: string; name, params, retType, superCall: var string; isFnConst, isOverride: var bool; isCtor: bool) =
var afterParams: string
var afterParams: string = ""
if scanf(val, "$*($*)$s$*", name, params, afterParams):
isFnConst = afterParams.find("const") > -1
isOverride = afterParams.find("override") > -1
@@ -1170,11 +1178,11 @@ proc genMemberProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool =
memberOp = "#->"
var typDesc = getTypeDescWeak(m, typ, check, dkParam)
let asPtrStr = rope(if asPtr: "_PTR" else: "")
var name, params, rettype, superCall: string
var isFnConst, isOverride: bool
var name, params, rettype, superCall: string = ""
var isFnConst, isOverride: bool = false
parseVFunctionDecl(prc.constraint.strVal, name, params, rettype, superCall, isFnConst, isOverride, isCtor)
genMemberProcParams(m, prc, superCall, rettype, params, check, true, false)
var fnConst, override: string
var fnConst, override: string = ""
if isCtor:
name = typDesc
if isFnConst:
@@ -1203,7 +1211,7 @@ proc genProcHeader(m: BModule; prc: PSym; result: var Rope; asPtr: bool = false)
var check = initIntSet()
fillBackendName(m, prc)
fillLoc(prc.loc, locProc, prc.ast[namePos], OnUnknown)
var rettype, params: Rope
var rettype, params: Rope = ""
genProcParams(m, prc.typ, rettype, params, check, true, false)
# handle the 2 options for hotcodereloading codegen - function pointer
# (instead of forward declaration) or header for function body with "_actual" postfix
@@ -1443,7 +1451,7 @@ proc genEnumInfo(m: BModule; typ: PType, name: Rope; info: TLineInfo) =
genTypeInfoAux(m, typ, typ, name, info)
var nodePtrs = getTempName(m) & "_" & $typ.n.len
genTNimNodeArray(m, nodePtrs, rope(typ.n.len))
var enumNames, specialCases: Rope
var enumNames, specialCases: Rope = ""
var firstNimNode = m.typeNodes
var hasHoles = false
for i in 0..<typ.n.len:
@@ -1522,6 +1530,7 @@ proc genTypeInfo2Name(m: BModule; t: PType): Rope =
result = it.sym.name.s
else:
var p = m.owner
result = ""
if p != nil and p.kind == skPackage:
result.add p.name.s & "."
result.add m.name.s & "."

5
compiler/ccgutils.nim
View File

@@ -19,13 +19,16 @@ when defined(nimPreviewSlimSystem):
proc getPragmaStmt*(n: PNode, w: TSpecialWord): PNode =
case n.kind
of nkStmtList:
result = nil
for i in 0..<n.len:
result = getPragmaStmt(n[i], w)
if result != nil: break
of nkPragma:
result = nil
for i in 0..<n.len:
if whichPragma(n[i]) == w: return n[i]
else: discard
else:
result = nil
proc stmtsContainPragma*(n: PNode, w: TSpecialWord): bool =
result = getPragmaStmt(n, w) != nil

27
compiler/cgen.nim
View File

@@ -291,6 +291,8 @@ proc freshLineInfo(p: BProc; info: TLineInfo): bool =
p.lastLineInfo.line = info.line
p.lastLineInfo.fileIndex = info.fileIndex
result = true
else:
result = false
proc genCLineDir(r: var Rope, p: BProc, info: TLineInfo; conf: ConfigRef) =
if optLineDir in conf.options:
@@ -432,7 +434,7 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: var TLoc,
linefmt(p, section, "$1.m_type = $2;$n", [r, genTypeInfoV1(p.module, t, a.lode.info)])
of frEmbedded:
if optTinyRtti in p.config.globalOptions:
var tmp: TLoc
var tmp: TLoc = default(TLoc)
if mode == constructRefObj:
let objType = t.skipTypes(abstractInst+{tyRef})
rawConstExpr(p, newNodeIT(nkType, a.lode.info, objType), tmp)
@@ -579,6 +581,7 @@ proc getIntTemp(p: BProc, result: var TLoc) =
result.flags = {}
proc localVarDecl(p: BProc; n: PNode): Rope =
result = ""
let s = n.sym
if s.loc.k == locNone:
fillLocalName(p, s)
@@ -646,7 +649,7 @@ proc callGlobalVarCppCtor(p: BProc; v: PSym; vn, value: PNode) =
let s = vn.sym
fillBackendName(p.module, s)
fillLoc(s.loc, locGlobalVar, vn, OnHeap)
var decl: Rope
var decl: Rope = ""
let td = getTypeDesc(p.module, vn.sym.typ, dkVar)
genGlobalVarDecl(p, vn, td, "", decl)
decl.add " " & $s.loc.r
@@ -867,7 +870,7 @@ proc symInDynamicLib(m: BModule, sym: PSym) =
inc(m.labels, 2)
if isCall:
let n = lib.path
var a: TLoc
var a: TLoc = default(TLoc)
initLocExpr(m.initProc, n[0], a)
var params = rdLoc(a) & "("
for i in 1..<n.len-1:
@@ -1003,6 +1006,7 @@ const harmless = {nkConstSection, nkTypeSection, nkEmpty, nkCommentStmt, nkTempl
declarativeDefs
proc easyResultAsgn(n: PNode): PNode =
result = nil
case n.kind
of nkStmtList, nkStmtListExpr:
var i = 0
@@ -1127,7 +1131,7 @@ proc allPathsAsgnResult(n: PNode): InitResultEnum =
proc getProcTypeCast(m: BModule, prc: PSym): Rope =
result = getTypeDesc(m, prc.loc.t)
if prc.typ.callConv == ccClosure:
var rettype, params: Rope
var rettype, params: Rope = ""
var check = initIntSet()
genProcParams(m, prc.typ, rettype, params, check)
result = "$1(*)$2" % [rettype, params]
@@ -1168,7 +1172,7 @@ proc genProcAux*(m: BModule, prc: PSym) =
if sfNoInit in prc.flags: incl(res.flags, sfNoInit)
if sfNoInit in prc.flags and p.module.compileToCpp and (let val = easyResultAsgn(procBody); val != nil):
var decl = localVarDecl(p, resNode)
var a: TLoc
var a: TLoc = default(TLoc)
initLocExprSingleUse(p, val, a)
linefmt(p, cpsStmts, "$1 = $2;$n", [decl, rdLoc(a)])
else:
@@ -1205,7 +1209,7 @@ proc genProcAux*(m: BModule, prc: PSym) =
prc.info = tmpInfo
var generatedProc: Rope
var generatedProc: Rope = ""
generatedProc.genCLineDir prc.info, m.config
if isNoReturn(p.module, prc):
if hasDeclspec in extccomp.CC[p.config.cCompiler].props:
@@ -1435,17 +1439,21 @@ proc getFileHeader(conf: ConfigRef; cfile: Cfile): Rope =
proc getSomeNameForModule(conf: ConfigRef, filename: AbsoluteFile): Rope =
## Returns a mangled module name.
result = ""
result.add mangleModuleName(conf, filename).mangle
proc getSomeNameForModule(m: BModule): Rope =
## Returns a mangled module name.
assert m.module.kind == skModule
assert m.module.owner.kind == skPackage
result = ""
result.add mangleModuleName(m.g.config, m.filename).mangle
proc getSomeInitName(m: BModule, suffix: string): Rope =
if not m.hcrOn:
result = getSomeNameForModule(m)
else:
result = ""
result.add suffix
proc getInitName(m: BModule): Rope =
@@ -1464,10 +1472,10 @@ proc genMainProc(m: BModule) =
## this function is called in cgenWriteModules after all modules are closed,
## it means raising dependency on the symbols is too late as it will not propagate
## into other modules, only simple rope manipulations are allowed
var preMainCode: Rope
var preMainCode: Rope = ""
if m.hcrOn:
proc loadLib(handle: string, name: string): Rope =
result = ""
let prc = magicsys.getCompilerProc(m.g.graph, name)
assert prc != nil
let n = newStrNode(nkStrLit, prc.annex.path.strVal)
@@ -1491,7 +1499,7 @@ proc genMainProc(m: BModule) =
else:
preMainCode.add("\t$1PreMain();\L" % [rope m.config.nimMainPrefix])
var posixCmdLine: Rope
var posixCmdLine: Rope = ""
if optNoMain notin m.config.globalOptions:
posixCmdLine.add "N_LIB_PRIVATE int cmdCount;\L"
posixCmdLine.add "N_LIB_PRIVATE char** cmdLine;\L"
@@ -2163,6 +2171,7 @@ proc updateCachedModule(m: BModule) =
proc finalCodegenActions*(graph: ModuleGraph; m: BModule; n: PNode): PNode =
## Also called from IC.
result = nil
if sfMainModule in m.module.flags:
# phase ordering problem here: We need to announce this
# dependency to 'nimTestErrorFlag' before system.c has been written to disk.

7
compiler/cgmeth.nim
View File

@@ -44,6 +44,8 @@ proc getDispatcher*(s: PSym): PSym =
if dispatcherPos < s.ast.len:
result = s.ast[dispatcherPos].sym
doAssert sfDispatcher in result.flags
else:
result = nil
proc methodCall*(n: PNode; conf: ConfigRef): PNode =
result = n
@@ -62,6 +64,7 @@ type
MethodResult = enum No, Invalid, Yes
proc sameMethodBucket(a, b: PSym; multiMethods: bool): MethodResult =
result = No
if a.name.id != b.name.id: return
if a.typ.len != b.typ.len:
return
@@ -149,7 +152,7 @@ proc fixupDispatcher(meth, disp: PSym; conf: ConfigRef) =
disp.ast[resultPos] = copyTree(meth.ast[resultPos])
proc methodDef*(g: ModuleGraph; idgen: IdGenerator; s: PSym) =
var witness: PSym
var witness: PSym = nil
for i in 0..<g.methods.len:
let disp = g.methods[i].dispatcher
case sameMethodBucket(disp, s, multimethods = optMultiMethods in g.config.globalOptions)
@@ -178,6 +181,7 @@ proc methodDef*(g: ModuleGraph; idgen: IdGenerator; s: PSym) =
proc relevantCol(methods: seq[PSym], col: int): bool =
# returns true iff the position is relevant
result = false
var t = methods[0].typ[col].skipTypes(skipPtrs)
if t.kind == tyObject:
for i in 1..high(methods):
@@ -186,6 +190,7 @@ proc relevantCol(methods: seq[PSym], col: int): bool =
return true
proc cmpSignatures(a, b: PSym, relevantCols: IntSet): int =
result = 0
for col in 1..<a.typ.len:
if contains(relevantCols, col):
var aa = skipTypes(a.typ[col], skipPtrs)

13
compiler/closureiters.nim
View File

@@ -258,8 +258,9 @@ proc hasYields(n: PNode): bool =
of nkYieldStmt:
result = true
of nkSkip:
discard
result = false
else:
result = false
for c in n:
if c.hasYields:
result = true
@@ -325,7 +326,7 @@ proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
var ifBranch: PNode
if c.len > 1:
var cond: PNode
var cond: PNode = nil
for i in 0..<c.len - 1:
assert(c[i].kind == nkType)
let nextCond = newTree(nkCall,
@@ -388,19 +389,22 @@ proc getFinallyNode(ctx: var Ctx, n: PNode): PNode =
proc hasYieldsInExpressions(n: PNode): bool =
case n.kind
of nkSkip:
discard
result = false
of nkStmtListExpr:
if isEmptyType(n.typ):
result = false
for c in n:
if c.hasYieldsInExpressions:
return true
else:
result = n.hasYields
of nkCast:
result = false
for i in 1..<n.len:
if n[i].hasYieldsInExpressions:
return true
else:
result = false
for c in n:
if c.hasYieldsInExpressions:
return true
@@ -495,7 +499,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
if ns:
needsSplit = true
var tmp: PSym
var tmp: PSym = nil
let isExpr = not isEmptyType(n.typ)
if isExpr:
tmp = ctx.newTempVar(n.typ)
@@ -1361,6 +1365,7 @@ proc freshVars(n: PNode; c: var FreshVarsContext): PNode =
else:
result.add it
of nkRaiseStmt:
result = nil
localError(c.config, c.info, "unsupported control flow: 'finally: ... raise' duplicated because of 'break'")
else:
result = n

47
compiler/commands.nim
View File

@@ -184,7 +184,7 @@ proc processSpecificNote*(arg: string, state: TSpecialWord, pass: TCmdLinePass,
info: TLineInfo; orig: string; conf: ConfigRef) =
var id = "" # arg = key or [key] or key:val or [key]:val; with val=on|off
var i = 0
var notes: set[TMsgKind]
var notes: set[TMsgKind] = {}
var isBracket = false
if i < arg.len and arg[i] == '[':
isBracket = true
@@ -263,13 +263,17 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
of "none": result = conf.selectedGC == gcNone
of "stack", "regions": result = conf.selectedGC == gcRegions
of "atomicarc": result = conf.selectedGC == gcAtomicArc
else: localError(conf, info, errNoneBoehmRefcExpectedButXFound % arg)
else:
result = false
localError(conf, info, errNoneBoehmRefcExpectedButXFound % arg)
of "opt":
case arg.normalize
of "speed": result = contains(conf.options, optOptimizeSpeed)
of "size": result = contains(conf.options, optOptimizeSize)
of "none": result = conf.options * {optOptimizeSpeed, optOptimizeSize} == {}
else: localError(conf, info, errNoneSpeedOrSizeExpectedButXFound % arg)
else:
result = false
localError(conf, info, errNoneSpeedOrSizeExpectedButXFound % arg)
of "verbosity": result = $conf.verbosity == arg
of "app":
case arg.normalize
@@ -279,7 +283,9 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
not contains(conf.globalOptions, optGenGuiApp)
of "staticlib": result = contains(conf.globalOptions, optGenStaticLib) and
not contains(conf.globalOptions, optGenGuiApp)
else: localError(conf, info, errGuiConsoleOrLibExpectedButXFound % arg)
else:
result = false
localError(conf, info, errGuiConsoleOrLibExpectedButXFound % arg)
of "dynliboverride":
result = isDynlibOverride(conf, arg)
of "exceptions":
@@ -288,8 +294,12 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
of "setjmp": result = conf.exc == excSetjmp
of "quirky": result = conf.exc == excQuirky
of "goto": result = conf.exc == excGoto
else: localError(conf, info, errInvalidExceptionSystem % arg)
else: invalidCmdLineOption(conf, passCmd1, switch, info)
else:
result = false
localError(conf, info, errInvalidExceptionSystem % arg)
else:
result = false
invalidCmdLineOption(conf, passCmd1, switch, info)
proc testCompileOption*(conf: ConfigRef; switch: string, info: TLineInfo): bool =
case switch.normalize
@@ -335,10 +345,14 @@ proc testCompileOption*(conf: ConfigRef; switch: string, info: TLineInfo): bool
if switch.normalize == "patterns": deprecatedAlias(switch, "trmacros")
result = contains(conf.options, optTrMacros)
of "excessivestacktrace": result = contains(conf.globalOptions, optExcessiveStackTrace)
of "nilseqs", "nilchecks", "taintmode": warningOptionNoop(switch)
of "nilseqs", "nilchecks", "taintmode":
warningOptionNoop(switch)
result = false
of "panics": result = contains(conf.globalOptions, optPanics)
of "jsbigint64": result = contains(conf.globalOptions, optJsBigInt64)
else: invalidCmdLineOption(conf, passCmd1, switch, info)
else:
result = false
invalidCmdLineOption(conf, passCmd1, switch, info)
proc processPath(conf: ConfigRef; path: string, info: TLineInfo,
notRelativeToProj = false): AbsoluteDir =
@@ -380,7 +394,8 @@ proc makeAbsolute(s: string): AbsoluteFile =
proc setTrackingInfo(conf: ConfigRef; dirty, file, line, column: string,
info: TLineInfo) =
## set tracking info, common code for track, trackDirty, & ideTrack
var ln, col: int
var ln: int = 0
var col: int = 0
if parseUtils.parseInt(line, ln) <= 0:
localError(conf, info, errInvalidNumber % line)
if parseUtils.parseInt(column, col) <= 0:
@@ -591,8 +606,8 @@ proc processMemoryManagementOption(switch, arg: string, pass: TCmdLinePass,
proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
conf: ConfigRef) =
var
key, val: string
var key = ""
var val = ""
case switch.normalize
of "eval":
expectArg(conf, switch, arg, pass, info)
@@ -1109,7 +1124,8 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
else: invalidCmdLineOption(conf, pass, switch, info)
proc processCommand*(switch: string, pass: TCmdLinePass; config: ConfigRef) =
var cmd, arg: string
var cmd = ""
var arg = ""
splitSwitch(config, switch, cmd, arg, pass, gCmdLineInfo)
processSwitch(cmd, arg, pass, gCmdLineInfo, config)
@@ -1136,7 +1152,10 @@ proc processArgument*(pass: TCmdLinePass; p: OptParser;
config.projectName = unixToNativePath(p.key)
config.arguments = cmdLineRest(p)
result = true
elif pass != passCmd2: setCommandEarly(config, p.key)
elif pass != passCmd2:
setCommandEarly(config, p.key)
result = false
else: result = false
else:
if pass == passCmd1: config.commandArgs.add p.key
if argsCount == 1:
@@ -1147,4 +1166,6 @@ proc processArgument*(pass: TCmdLinePass; p: OptParser;
config.projectName = unixToNativePath(p.key)
config.arguments = cmdLineRest(p)
result = true
else:
result = false
inc argsCount

7
compiler/concepts.nim
View File

@@ -121,8 +121,11 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
for i in 0..<a.len:
if not matchType(c, f[i], a[i], m): return false
return true
else:
result = false
of tyGenericInvocation:
result = false
if a.kind == tyGenericInst and a[0].kind == tyGenericBody:
if sameType(f[0], a[0]) and f.len == a.len-1:
for i in 1 ..< f.len:
@@ -156,6 +159,8 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
result = matchType(c, old, ak, m)
if m.magic == mArrPut and ak.kind == tyGenericParam:
result = true
else:
result = false
#echo "B for ", result, " to ", typeToString(a), " to ", typeToString(m.potentialImplementation)
of tyVar, tySink, tyLent, tyOwned:
@@ -185,6 +190,7 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
m.inferred.setLen oldLen
of tyArray, tyTuple, tyVarargs, tyOpenArray, tyRange, tySequence, tyRef, tyPtr,
tyGenericInst:
result = false
let ak = a.skipTypes(ignorableForArgType - {f.kind})
if ak.kind == f.kind and f.len == ak.len:
for i in 0..<ak.len:
@@ -209,6 +215,7 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
if not result:
m.inferred.setLen oldLen
else:
result = false
for i in 0..<f.len:
result = matchType(c, f[i], a, m)
if result: break # and remember the binding!

2
compiler/condsyms.nim
View File

@@ -158,3 +158,5 @@ proc initDefines*(symbols: StringTableRef) =
defineSymbol("nimAllowNonVarDestructor")
defineSymbol("nimHasQuirky")
defineSymbol("nimHasEnsureMove")
defineSymbol("nimUseStrictDefs")

1
compiler/depends.nim
View File

@@ -42,6 +42,7 @@ proc toNimblePath(s: string, isStdlib: bool): string =
let sub = "lib/"
var start = s.find(sub)
if start < 0:
result = ""
doAssert false
else:
start += sub.len

5
compiler/dfa.nim
View File

@@ -60,6 +60,7 @@ type
proc codeListing(c: ControlFlowGraph, start = 0; last = -1): string =
# for debugging purposes
# first iteration: compute all necessary labels:
result = ""
var jumpTargets = initIntSet()
let last = if last < 0: c.len-1 else: min(last, c.len-1)
for i in start..last:
@@ -111,7 +112,7 @@ proc patch(c: var Con, p: TPosition) =
proc gen(c: var Con; n: PNode)
proc popBlock(c: var Con; oldLen: int) =
var exits: seq[TPosition]
var exits: seq[TPosition] = @[]
exits.add c.gotoI()
for f in c.blocks[oldLen].breakFixups:
c.patch(f[0])
@@ -263,7 +264,7 @@ proc genBreakOrRaiseAux(c: var Con, i: int, n: PNode) =
if c.blocks[i].isTryBlock:
c.blocks[i].raiseFixups.add lab1
else:
var trailingFinales: seq[PNode]
var trailingFinales: seq[PNode] = @[]
if c.inTryStmt > 0:
# Ok, we are in a try, lets see which (if any) try's we break out from:
for b in countdown(c.blocks.high, i):

46
compiler/docgen.nim
View File

@@ -170,6 +170,7 @@ proc cmpDecimalsIgnoreCase(a, b: string): int =
proc prettyString(a: object): string =
# xxx pending std/prettyprint refs https://github.com/nim-lang/RFCs/issues/203#issuecomment-602534906
result = ""
for k, v in fieldPairs(a):
result.add k & ": " & $v & "\n"
@@ -215,12 +216,16 @@ proc whichType(d: PDoc; n: PNode): PSym =
if n.kind == nkSym:
if d.types.strTableContains(n.sym):
result = n.sym
else:
result = nil
else:
result = nil
for i in 0..<n.safeLen:
let x = whichType(d, n[i])
if x != nil: return x
proc attachToType(d: PDoc; p: PSym): PSym =
result = nil
let params = p.ast[paramsPos]
template check(i) =
result = whichType(d, params[i])
@@ -435,6 +440,8 @@ proc genComment(d: PDoc, n: PNode): PRstNode =
d.conf, d.sharedState)
except ERecoverableError:
result = newRstNode(rnLiteralBlock, @[newRstLeaf(n.comment)])
else:
result = nil
proc genRecCommentAux(d: PDoc, n: PNode): PRstNode =
if n == nil: return nil
@@ -469,6 +476,7 @@ proc getPlainDocstring(n: PNode): string =
elif startsWith(n.comment, "##"):
result = n.comment
else:
result = ""
for i in 0..<n.safeLen:
result = getPlainDocstring(n[i])
if result.len > 0: return
@@ -484,7 +492,7 @@ proc externalDep(d: PDoc; module: PSym): string =
proc nodeToHighlightedHtml(d: PDoc; n: PNode; result: var string;
renderFlags: TRenderFlags = {};
procLink: string) =
var r: TSrcGen
var r: TSrcGen = TSrcGen()
var literal = ""
initTokRender(r, n, renderFlags)
var kind = tkEof
@@ -600,7 +608,9 @@ proc runAllExamples(d: PDoc) =
rawMessage(d.conf, hintSuccess, ["runnableExamples: " & outp.string])
# removeFile(outp.changeFileExt(ExeExt)) # it's in nimcache, no need to remove
proc quoted(a: string): string = result.addQuoted(a)
proc quoted(a: string): string =
result = ""
result.addQuoted(a)
proc toInstantiationInfo(conf: ConfigRef, info: TLineInfo): (string, int, int) =
# xxx expose in compiler/lineinfos.nim
@@ -726,7 +736,7 @@ proc getAllRunnableExamplesImpl(d: PDoc; n: PNode, dest: var ItemPre,
let (rdoccmd, code) = prepareExample(d, n, topLevel)
var msg = "Example:"
if rdoccmd.len > 0: msg.add " cmd: " & rdoccmd
var s: string
var s: string = ""
dispA(d.conf, s, "\n<p><strong class=\"examples_text\">$1</strong></p>\n",
"\n\n\\textbf{$1}\n", [msg])
dest.add s
@@ -942,7 +952,10 @@ proc genDeprecationMsg(d: PDoc, n: PNode): string =
if n[1].kind in {nkStrLit..nkTripleStrLit}:
result = getConfigVar(d.conf, "doc.deprecationmsg") % [
"label", "Deprecated:", "message", xmltree.escape(n[1].strVal)]
else:
result = ""
else:
result = ""
doAssert false
type DocFlags = enum
@@ -950,6 +963,7 @@ type DocFlags = enum
kForceExport
proc genSeeSrc(d: PDoc, path: string, line: int): string =
result = ""
let docItemSeeSrc = getConfigVar(d.conf, "doc.item.seesrc")
if docItemSeeSrc.len > 0:
let path = relativeTo(AbsoluteFile path, AbsoluteDir getCurrentDir(), '/')
@@ -991,7 +1005,7 @@ proc toLangSymbol(k: TSymKind, n: PNode, baseName: string): LangSymbol =
result.symKind = k.toHumanStr
if k in routineKinds:
var
paramTypes: seq[string]
paramTypes: seq[string] = @[]
renderParamTypes(paramTypes, n[paramsPos], toNormalize=true)
let paramNames = renderParamNames(n[paramsPos], toNormalize=true)
# In some rare cases (system.typeof) parameter type is not set for default:
@@ -1038,7 +1052,7 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
var result = ""
var literal, plainName = ""
var kind = tkEof
var comm: ItemPre
var comm: ItemPre = default(ItemPre)
if n.kind in routineDefs:
getAllRunnableExamples(d, n, comm)
else:
@@ -1150,7 +1164,7 @@ proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false):
var
name = getNameEsc(d, nameNode)
comm = genRecComment(d, n)
r: TSrcGen
r: TSrcGen = default(TSrcGen)
renderFlags = {renderNoBody, renderNoComments, renderDocComments, renderExpandUsing}
if nonExports:
renderFlags.incl renderNonExportedFields
@@ -1283,6 +1297,8 @@ proc documentNewEffect(cache: IdentCache; n: PNode): PNode =
let s = n[namePos].sym
if tfReturnsNew in s.typ.flags:
result = newIdentNode(getIdent(cache, "new"), n.info)
else:
result = nil
proc documentEffect(cache: IdentCache; n, x: PNode, effectType: TSpecialWord, idx: int): PNode =
let spec = effectSpec(x, effectType)
@@ -1305,6 +1321,8 @@ proc documentEffect(cache: IdentCache; n, x: PNode, effectType: TSpecialWord, id
result = newTreeI(nkExprColonExpr, n.info,
newIdentNode(getIdent(cache, $effectType), n.info), effects)
else:
result = nil
proc documentWriteEffect(cache: IdentCache; n: PNode; flag: TSymFlag; pragmaName: string): PNode =
let s = n[namePos].sym
@@ -1318,6 +1336,8 @@ proc documentWriteEffect(cache: IdentCache; n: PNode; flag: TSymFlag; pragmaName
if effects.len > 0:
result = newTreeI(nkExprColonExpr, n.info,
newIdentNode(getIdent(cache, pragmaName), n.info), effects)
else:
result = nil
proc documentRaises*(cache: IdentCache; n: PNode) =
if n[namePos].kind != nkSym: return
@@ -1391,7 +1411,7 @@ proc generateDoc*(d: PDoc, n, orig: PNode, config: ConfigRef, docFlags: DocFlags
of nkExportExceptStmt: discard "transformed into nkExportStmt by semExportExcept"
of nkFromStmt, nkImportExceptStmt: traceDeps(d, n[0])
of nkCallKinds:
var comm: ItemPre
var comm: ItemPre = default(ItemPre)
getAllRunnableExamples(d, n, comm)
if comm.len != 0: d.modDescPre.add(comm)
else: discard
@@ -1500,7 +1520,7 @@ proc finishGenerateDoc*(d: var PDoc) =
overloadChoices.sort(cmp)
var nameContent = ""
for item in overloadChoices:
var itemDesc: string
var itemDesc: string = ""
renderItemPre(d, item.descRst, itemDesc)
nameContent.add(
getConfigVar(d.conf, "doc.item") % (
@@ -1526,7 +1546,7 @@ proc finishGenerateDoc*(d: var PDoc) =
for i, entry in d.jEntriesPre:
if entry.rst != nil:
let resolved = resolveSubs(d.sharedState, entry.rst)
var str: string
var str: string = ""
renderRstToOut(d[], resolved, str)
entry.json[entry.rstField] = %str
d.jEntriesPre[i].rst = nil
@@ -1641,7 +1661,7 @@ proc genSection(d: PDoc, kind: TSymKind, groupedToc = false) =
for plainName in overloadableNames.sorted(cmpDecimalsIgnoreCase):
var overloadChoices = d.tocTable[kind][plainName]
overloadChoices.sort(cmp)
var content: string
var content: string = ""
for item in overloadChoices:
content.add item.content
d.toc2[kind].add getConfigVar(d.conf, "doc.section.toc2") % [
@@ -1672,7 +1692,7 @@ proc relLink(outDir: AbsoluteDir, destFile: AbsoluteFile, linkto: RelativeFile):
proc genOutFile(d: PDoc, groupedToc = false): string =
var
code, content: string
code, content: string = ""
title = ""
var j = 0
var toc = ""
@@ -1781,7 +1801,7 @@ proc writeOutput*(d: PDoc, useWarning = false, groupedToc = false) =
proc writeOutputJson*(d: PDoc, useWarning = false) =
runAllExamples(d)
var modDesc: string
var modDesc: string = ""
for desc in d.modDescFinal:
modDesc &= desc
let content = %*{"orig": d.filename,
@@ -1793,7 +1813,7 @@ proc writeOutputJson*(d: PDoc, useWarning = false) =
else:
let dir = d.destFile.splitFile.dir
createDir(dir)
var f: File
var f: File = default(File)
if open(f, d.destFile, fmWrite):
write(f, $content)
close(f)

2
compiler/docgen2.nim
View File

@@ -39,10 +39,12 @@ template closeImpl(body: untyped) {.dirty.} =
discard
proc closeDoc*(graph: ModuleGraph; p: PPassContext, n: PNode): PNode =
result = nil
closeImpl:
writeOutput(g.doc, useWarning, groupedToc)
proc closeJson*(graph: ModuleGraph; p: PPassContext, n: PNode): PNode =
result = nil
closeImpl:
writeOutputJson(g.doc, useWarning)

1
compiler/enumtostr.nim
View File

@@ -56,6 +56,7 @@ proc searchObjCaseImpl(obj: PNode; field: PSym): PNode =
if obj.kind == nkRecCase and obj[0].kind == nkSym and obj[0].sym == field:
result = obj
else:
result = nil
for x in obj:
result = searchObjCaseImpl(x, field)
if result != nil: break

23
compiler/evalffi.nim
View File

@@ -37,9 +37,10 @@ else:
var gExeHandle = loadLib()
proc getDll(conf: ConfigRef, cache: var TDllCache; dll: string; info: TLineInfo): pointer =
result = nil
if dll in cache:
return cache[dll]
var libs: seq[string]
var libs: seq[string] = @[]
libCandidates(dll, libs)
for c in libs:
result = loadLib(c)
@@ -61,7 +62,7 @@ proc importcSymbol*(conf: ConfigRef, sym: PSym): PNode =
let lib = sym.annex
if lib != nil and lib.path.kind notin {nkStrLit..nkTripleStrLit}:
globalError(conf, sym.info, "dynlib needs to be a string lit")
var theAddr: pointer
var theAddr: pointer = nil
if (lib.isNil or lib.kind == libHeader) and not gExeHandle.isNil:
libPathMsg = "current exe: " & getAppFilename() & " nor libc: " & libcDll
# first try this exe itself:
@@ -108,6 +109,7 @@ proc mapCallConv(conf: ConfigRef, cc: TCallingConvention, info: TLineInfo): TABI
of ccStdCall: result = when defined(windows) and defined(x86): STDCALL else: DEFAULT_ABI
of ccCDecl: result = DEFAULT_ABI
else:
result = default(TABI)
globalError(conf, info, "cannot map calling convention to FFI")
template rd(typ, p: untyped): untyped = (cast[ptr typ](p))[]
@@ -132,6 +134,8 @@ proc packSize(conf: ConfigRef, v: PNode, typ: PType): int =
result = sizeof(pointer)
elif v.len != 0:
result = v.len * packSize(conf, v[0], typ[1])
else:
result = 0
else:
result = getSize(conf, typ).int
@@ -140,6 +144,7 @@ proc pack(conf: ConfigRef, v: PNode, typ: PType, res: pointer)
proc getField(conf: ConfigRef, n: PNode; position: int): PSym =
case n.kind
of nkRecList:
result = nil
for i in 0..<n.len:
result = getField(conf, n[i], position)
if result != nil: return
@@ -154,7 +159,8 @@ proc getField(conf: ConfigRef, n: PNode; position: int): PSym =
else: internalError(conf, n.info, "getField(record case branch)")
of nkSym:
if n.sym.position == position: result = n.sym
else: discard
else: result = nil
else: result = nil
proc packObject(conf: ConfigRef, x: PNode, typ: PType, res: pointer) =
internalAssert conf, x.kind in {nkObjConstr, nkPar, nkTupleConstr}
@@ -356,6 +362,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
of 4: awi(nkIntLit, rd(int32, x).BiggestInt)
of 8: awi(nkIntLit, rd(int64, x).BiggestInt)
else:
result = nil
globalError(conf, n.info, "cannot map value from FFI (tyEnum, tySet)")
of tyFloat: awf(nkFloatLit, rd(float, x))
of tyFloat32: awf(nkFloat32Lit, rd(float32, x))
@@ -381,6 +388,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
n[0] = unpack(conf, p, typ.lastSon, n[0])
result = n
else:
result = nil
globalError(conf, n.info, "cannot map value from FFI " & typeToString(typ))
of tyObject, tyTuple:
result = unpackObject(conf, x, typ, n)
@@ -398,6 +406,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
result = unpack(conf, x, typ.lastSon, n)
else:
# XXX what to do with 'array' here?
result = nil
globalError(conf, n.info, "cannot map value from FFI " & typeToString(typ))
proc fficast*(conf: ConfigRef, x: PNode, destTyp: PType): PNode =
@@ -424,7 +433,7 @@ proc callForeignFunction*(conf: ConfigRef, call: PNode): PNode =
internalAssert conf, call[0].kind == nkPtrLit
var cif: TCif
var sig: ParamList
var sig: ParamList = default(ParamList)
# use the arguments' types for varargs support:
for i in 1..<call.len:
sig[i-1] = mapType(conf, call[i].typ)
@@ -436,7 +445,7 @@ proc callForeignFunction*(conf: ConfigRef, call: PNode): PNode =
mapType(conf, typ[0]), sig) != OK:
globalError(conf, call.info, "error in FFI call")
var args: ArgList
var args: ArgList = default(ArgList)
let fn = cast[pointer](call[0].intVal)
for i in 1..<call.len:
var t = call[i].typ
@@ -464,7 +473,7 @@ proc callForeignFunction*(conf: ConfigRef, fn: PNode, fntyp: PType,
internalAssert conf, fn.kind == nkPtrLit
var cif: TCif
var sig: ParamList
var sig: ParamList = default(ParamList)
for i in 0..len-1:
var aTyp = args[i+start].typ
if aTyp.isNil:
@@ -478,7 +487,7 @@ proc callForeignFunction*(conf: ConfigRef, fn: PNode, fntyp: PType,
mapType(conf, fntyp[0]), sig) != OK:
globalError(conf, info, "error in FFI call")
var cargs: ArgList
var cargs: ArgList = default(ArgList)
let fn = cast[pointer](fn.intVal)
for i in 0..len-1:
let t = args[i+start].typ

25
compiler/extccomp.nim
View File

@@ -486,6 +486,10 @@ proc vccplatform(conf: ConfigRef): string =
of cpuArm: " --platform:arm"
of cpuAmd64: " --platform:amd64"
else: ""
else:
result = ""
else:
result = ""
proc getLinkOptions(conf: ConfigRef): string =
result = conf.linkOptions & " " & conf.linkOptionsCmd & " "
@@ -534,7 +538,7 @@ proc ccHasSaneOverflow*(conf: ConfigRef): bool =
# NOTE: should we need the full version, use -dumpfullversion
let (s, exitCode) = try: execCmdEx(exe & " -dumpversion") except IOError, OSError, ValueError: ("", 1)
if exitCode == 0:
var major: int
var major: int = 0
discard parseInt(s, major)
result = major >= 5
else:
@@ -644,7 +648,7 @@ proc externalFileChanged(conf: ConfigRef; cfile: Cfile): bool =
let hashFile = toGeneratedFile(conf, conf.mangleModuleName(cfile.cname).AbsoluteFile, "sha1")
let currentHash = footprint(conf, cfile)
var f: File
var f: File = default(File)
if open(f, hashFile.string, fmRead):
let oldHash = parseSecureHash(f.readLine())
close(f)
@@ -779,6 +783,7 @@ template tryExceptOSErrorMessage(conf: ConfigRef; errorPrefix: string = "", body
raise
proc getExtraCmds(conf: ConfigRef; output: AbsoluteFile): seq[string] =
result = @[]
when defined(macosx):
if optCDebug in conf.globalOptions and optGenStaticLib notin conf.globalOptions:
# if needed, add an option to skip or override location
@@ -861,6 +866,7 @@ proc hcrLinkTargetName(conf: ConfigRef, objFile: string, isMain = false): Absolu
result = conf.getNimcacheDir / RelativeFile(targetName)
proc displayProgressCC(conf: ConfigRef, path, compileCmd: string): string =
result = ""
if conf.hasHint(hintCC):
if optListCmd in conf.globalOptions or conf.verbosity > 1:
result = MsgKindToStr[hintCC] % (demangleModuleName(path.splitFile.name) & ": " & compileCmd)
@@ -883,15 +889,15 @@ proc preventLinkCmdMaxCmdLen(conf: ConfigRef, linkCmd: string) =
proc callCCompiler*(conf: ConfigRef) =
var
linkCmd: string
linkCmd: string = ""
extraCmds: seq[string]
if conf.globalOptions * {optCompileOnly, optGenScript} == {optCompileOnly}:
return # speed up that call if only compiling and no script shall be
# generated
#var c = cCompiler
var script: Rope = ""
var cmds: TStringSeq
var prettyCmds: TStringSeq
var cmds: TStringSeq = default(TStringSeq)
var prettyCmds: TStringSeq = default(TStringSeq)
let prettyCb = proc (idx: int) = writePrettyCmdsStderr(prettyCmds[idx])
for idx, it in conf.toCompile:
@@ -1022,8 +1028,9 @@ proc writeJsonBuildInstructions*(conf: ConfigRef) =
conf.jsonBuildFile.string.writeFile(bcache.toJson.pretty)
proc changeDetectedViaJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile): bool =
result = false
if not fileExists(jsonFile) or not fileExists(conf.absOutFile): return true
var bcache: BuildCache
var bcache: BuildCache = default(BuildCache)
try: bcache.fromJson(jsonFile.string.parseFile)
except IOError, OSError, ValueError:
stderr.write "Warning: JSON processing failed for: $#\n" % jsonFile.string
@@ -1039,7 +1046,7 @@ proc changeDetectedViaJsonBuildInstructions*(conf: ConfigRef; jsonFile: Absolute
if $secureHashFile(file) != hash: return true
proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
var bcache: BuildCache
var bcache: BuildCache = default(BuildCache)
try: bcache.fromJson(jsonFile.string.parseFile)
except ValueError, KeyError, JsonKindError:
let e = getCurrentException()
@@ -1052,7 +1059,8 @@ proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
globalError(conf, gCmdLineInfo,
"jsonscript command outputFile '$1' must match '$2' which was specified during --compileOnly, see \"outputFile\" entry in '$3' " %
[outputCurrent, output, jsonFile.string])
var cmds, prettyCmds: TStringSeq
var cmds: TStringSeq = default(TStringSeq)
var prettyCmds: TStringSeq= default(TStringSeq)
let prettyCb = proc (idx: int) = writePrettyCmdsStderr(prettyCmds[idx])
for (name, cmd) in bcache.compile:
cmds.add cmd
@@ -1062,6 +1070,7 @@ proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
for cmd in bcache.extraCmds: execExternalProgram(conf, cmd, hintExecuting)
proc genMappingFiles(conf: ConfigRef; list: CfileList): Rope =
result = ""
for it in list:
result.addf("--file:r\"$1\"$N", [rope(it.cname.string)])

13
compiler/filters.nim
View File

@@ -29,23 +29,30 @@ proc getArg(conf: ConfigRef; n: PNode, name: string, pos: int): PNode =
return n[i]
proc charArg*(conf: ConfigRef; n: PNode, name: string, pos: int, default: char): char =
var x = getArg(conf, n, name, pos)
if x == nil: result = default
elif x.kind == nkCharLit: result = chr(int(x.intVal))
else: invalidPragma(conf, n)
else:
result = default(char)
invalidPragma(conf, n)
proc strArg*(conf: ConfigRef; n: PNode, name: string, pos: int, default: string): string =
var x = getArg(conf, n, name, pos)
if x == nil: result = default
elif x.kind in {nkStrLit..nkTripleStrLit}: result = x.strVal
else: invalidPragma(conf, n)
else:
result = ""
invalidPragma(conf, n)
proc boolArg*(conf: ConfigRef; n: PNode, name: string, pos: int, default: bool): bool =
var x = getArg(conf, n, name, pos)
if x == nil: result = default
elif x.kind == nkIdent and cmpIgnoreStyle(x.ident.s, "true") == 0: result = true
elif x.kind == nkIdent and cmpIgnoreStyle(x.ident.s, "false") == 0: result = false
else: invalidPragma(conf, n)
else:
result = false
invalidPragma(conf, n)
proc filterStrip*(conf: ConfigRef; stdin: PLLStream, filename: AbsoluteFile, call: PNode): PLLStream =
var pattern = strArg(conf, call, "startswith", 1, "")

3
compiler/gorgeimpl.nim
View File

@@ -29,10 +29,11 @@ proc readOutput(p: Process): (string, int) =
proc opGorge*(cmd, input, cache: string, info: TLineInfo; conf: ConfigRef): (string, int) =
let workingDir = parentDir(toFullPath(conf, info))
result = ("", 0)
if cache.len > 0:
let h = secureHash(cmd & "\t" & input & "\t" & cache)
let filename = toGeneratedFile(conf, AbsoluteFile("gorge_" & $h), "txt").string
var f: File
var f: File = default(File)
if optForceFullMake notin conf.globalOptions and open(f, filename):
result = (f.readAll, 0)
f.close

148
compiler/guards.nim
View File

@@ -51,6 +51,10 @@ proc isLet(n: PNode): bool =
elif n.sym.kind == skParam and skipTypes(n.sym.typ,
abstractInst).kind notin {tyVar}:
result = true
else:
result = false
else:
result = false
proc isVar(n: PNode): bool =
n.kind == nkSym and n.sym.kind in {skResult, skVar} and
@@ -136,6 +140,8 @@ proc neg(n: PNode; o: Operators): PNode =
result = a
elif b != nil:
result = b
else:
result = nil
else:
# leave not (a == 4) as it is
result = newNodeI(nkCall, n.info, 2)
@@ -330,6 +336,8 @@ proc usefulFact(n: PNode; o: Operators): PNode =
result = n
elif n[1].getMagic in someLen or n[2].getMagic in someLen:
result = n
else:
result = nil
of someLe+someLt:
if isLetLocation(n[1], true) or isLetLocation(n[2], true):
# XXX algebraic simplifications! 'i-1 < a.len' --> 'i < a.len+1'
@@ -337,12 +345,18 @@ proc usefulFact(n: PNode; o: Operators): PNode =
elif n[1].getMagic in someLen or n[2].getMagic in someLen:
# XXX Rethink this whole idea of 'usefulFact' for semparallel
result = n
else:
result = nil
of mIsNil:
if isLetLocation(n[1], false) or isVar(n[1]):
result = n
else:
result = nil
of someIn:
if isLetLocation(n[1], true):
result = n
else:
result = nil
of mAnd:
let
a = usefulFact(n[1], o)
@@ -356,10 +370,14 @@ proc usefulFact(n: PNode; o: Operators): PNode =
result = a
elif b != nil:
result = b
else:
result = nil
of mNot:
let a = usefulFact(n[1], o)
if a != nil:
result = a.neg(o)
else:
result = nil
of mOr:
# 'or' sucks! (p.isNil or q.isNil) --> hard to do anything
# with that knowledge...
@@ -376,6 +394,8 @@ proc usefulFact(n: PNode; o: Operators): PNode =
result[1] = a
result[2] = b
result = result.neg(o)
else:
result = nil
elif n.kind == nkSym and n.sym.kind == skLet:
# consider:
# let a = 2 < x
@@ -384,8 +404,12 @@ proc usefulFact(n: PNode; o: Operators): PNode =
# We make can easily replace 'a' by '2 < x' here:
if n.sym.astdef != nil:
result = usefulFact(n.sym.astdef, o)
else:
result = nil
elif n.kind == nkStmtListExpr:
result = usefulFact(n.lastSon, o)
else:
result = nil
type
TModel* = object
@@ -451,8 +475,9 @@ proc hasSubTree(n, x: PNode): bool =
of nkEmpty..nkNilLit:
result = n.sameTree(x)
of nkFormalParams:
discard
result = false
else:
result = false
for i in 0..<n.len:
if hasSubTree(n[i], x): return true
@@ -483,6 +508,8 @@ proc invalidateFacts*(m: var TModel, n: PNode) =
proc valuesUnequal(a, b: PNode): bool =
if a.isValue and b.isValue:
result = not sameValue(a, b)
else:
result = false
proc impliesEq(fact, eq: PNode): TImplication =
let (loc, val) = if isLocation(eq[1]): (1, 2) else: (2, 1)
@@ -493,16 +520,26 @@ proc impliesEq(fact, eq: PNode): TImplication =
# this is not correct; consider: a == b; a == 1 --> unknown!
if sameTree(fact[2], eq[val]): result = impYes
elif valuesUnequal(fact[2], eq[val]): result = impNo
else:
result = impUnknown
elif sameTree(fact[2], eq[loc]):
if sameTree(fact[1], eq[val]): result = impYes
elif valuesUnequal(fact[1], eq[val]): result = impNo
else:
result = impUnknown
else:
result = impUnknown
of mInSet:
# remember: mInSet is 'contains' so the set comes first!
if sameTree(fact[2], eq[loc]) and isValue(eq[val]):
if inSet(fact[1], eq[val]): result = impYes
else: result = impNo
of mNot, mOr, mAnd: assert(false, "impliesEq")
else: discard
else:
result = impUnknown
of mNot, mOr, mAnd:
result = impUnknown
assert(false, "impliesEq")
else: result = impUnknown
proc leImpliesIn(x, c, aSet: PNode): TImplication =
if c.kind in {nkCharLit..nkUInt64Lit}:
@@ -512,13 +549,19 @@ proc leImpliesIn(x, c, aSet: PNode): TImplication =
var value = newIntNode(c.kind, firstOrd(nil, x.typ))
# don't iterate too often:
if c.intVal - value.intVal < 1000:
var i, pos, neg: int
var i, pos, neg: int = 0
while value.intVal <= c.intVal:
if inSet(aSet, value): inc pos
else: inc neg
inc i; inc value.intVal
if pos == i: result = impYes
elif neg == i: result = impNo
else:
result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
proc geImpliesIn(x, c, aSet: PNode): TImplication =
if c.kind in {nkCharLit..nkUInt64Lit}:
@@ -529,17 +572,23 @@ proc geImpliesIn(x, c, aSet: PNode): TImplication =
let max = lastOrd(nil, x.typ)
# don't iterate too often:
if max - getInt(value) < toInt128(1000):
var i, pos, neg: int
var i, pos, neg: int = 0
while value.intVal <= max:
if inSet(aSet, value): inc pos
else: inc neg
inc i; inc value.intVal
if pos == i: result = impYes
elif neg == i: result = impNo
else: result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
proc compareSets(a, b: PNode): TImplication =
if equalSets(nil, a, b): result = impYes
elif intersectSets(nil, a, b).len == 0: result = impNo
else: result = impUnknown
proc impliesIn(fact, loc, aSet: PNode): TImplication =
case fact[0].sym.magic
@@ -550,22 +599,32 @@ proc impliesIn(fact, loc, aSet: PNode): TImplication =
elif sameTree(fact[2], loc):
if inSet(aSet, fact[1]): result = impYes
else: result = impNo
else:
result = impUnknown
of mInSet:
if sameTree(fact[2], loc):
result = compareSets(fact[1], aSet)
else:
result = impUnknown
of someLe:
if sameTree(fact[1], loc):
result = leImpliesIn(fact[1], fact[2], aSet)
elif sameTree(fact[2], loc):
result = geImpliesIn(fact[2], fact[1], aSet)
else:
result = impUnknown
of someLt:
if sameTree(fact[1], loc):
result = leImpliesIn(fact[1], fact[2].pred, aSet)
elif sameTree(fact[2], loc):
# 4 < x --> 3 <= x
result = geImpliesIn(fact[2], fact[1].pred, aSet)
of mNot, mOr, mAnd: assert(false, "impliesIn")
else: discard
else:
result = impUnknown
of mNot, mOr, mAnd:
result = impUnknown
assert(false, "impliesIn")
else: result = impUnknown
proc valueIsNil(n: PNode): TImplication =
if n.kind == nkNilLit: impYes
@@ -577,13 +636,19 @@ proc impliesIsNil(fact, eq: PNode): TImplication =
of mIsNil:
if sameTree(fact[1], eq[1]):
result = impYes
else:
result = impUnknown
of someEq:
if sameTree(fact[1], eq[1]):
result = valueIsNil(fact[2].skipConv)
elif sameTree(fact[2], eq[1]):
result = valueIsNil(fact[1].skipConv)
of mNot, mOr, mAnd: assert(false, "impliesIsNil")
else: discard
else:
result = impUnknown
of mNot, mOr, mAnd:
result = impUnknown
assert(false, "impliesIsNil")
else: result = impUnknown
proc impliesGe(fact, x, c: PNode): TImplication =
assert isLocation(x)
@@ -594,32 +659,57 @@ proc impliesGe(fact, x, c: PNode): TImplication =
# fact: x = 4; question x >= 56? --> true iff 4 >= 56
if leValue(c, fact[2]): result = impYes
else: result = impNo
else:
result = impUnknown
elif sameTree(fact[2], x):
if isValue(fact[1]) and isValue(c):
if leValue(c, fact[1]): result = impYes
else: result = impNo
else:
result = impUnknown
else:
result = impUnknown
of someLt:
if sameTree(fact[1], x):
if isValue(fact[2]) and isValue(c):
# fact: x < 4; question N <= x? --> false iff N <= 4
if leValue(fact[2], c): result = impNo
else: result = impUnknown
# fact: x < 4; question 2 <= x? --> we don't know
else:
result = impUnknown
elif sameTree(fact[2], x):
# fact: 3 < x; question: N-1 < x ? --> true iff N-1 <= 3
if isValue(fact[1]) and isValue(c):
if leValue(c.pred, fact[1]): result = impYes
else: result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
of someLe:
if sameTree(fact[1], x):
if isValue(fact[2]) and isValue(c):
# fact: x <= 4; question x >= 56? --> false iff 4 <= 56
if leValue(fact[2], c): result = impNo
# fact: x <= 4; question x >= 2? --> we don't know
else:
result = impUnknown
else:
result = impUnknown
elif sameTree(fact[2], x):
# fact: 3 <= x; question: x >= 2 ? --> true iff 2 <= 3
if isValue(fact[1]) and isValue(c):
if leValue(c, fact[1]): result = impYes
of mNot, mOr, mAnd: assert(false, "impliesGe")
else: discard
else: result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
of mNot, mOr, mAnd:
result = impUnknown
assert(false, "impliesGe")
else: result = impUnknown
proc impliesLe(fact, x, c: PNode): TImplication =
if not isLocation(x):
@@ -634,35 +724,59 @@ proc impliesLe(fact, x, c: PNode): TImplication =
# fact: x = 4; question x <= 56? --> true iff 4 <= 56
if leValue(fact[2], c): result = impYes
else: result = impNo
else:
result = impUnknown
elif sameTree(fact[2], x):
if isValue(fact[1]) and isValue(c):
if leValue(fact[1], c): result = impYes
else: result = impNo
else:
result = impUnknown
else:
result = impUnknown
of someLt:
if sameTree(fact[1], x):
if isValue(fact[2]) and isValue(c):
# fact: x < 4; question x <= N? --> true iff N-1 <= 4
if leValue(fact[2], c.pred): result = impYes
else:
result = impUnknown
# fact: x < 4; question x <= 2? --> we don't know
else:
result = impUnknown
elif sameTree(fact[2], x):
# fact: 3 < x; question: x <= 1 ? --> false iff 1 <= 3
if isValue(fact[1]) and isValue(c):
if leValue(c, fact[1]): result = impNo
else: result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
of someLe:
if sameTree(fact[1], x):
if isValue(fact[2]) and isValue(c):
# fact: x <= 4; question x <= 56? --> true iff 4 <= 56
if leValue(fact[2], c): result = impYes
else: result = impUnknown
# fact: x <= 4; question x <= 2? --> we don't know
else:
result = impUnknown
elif sameTree(fact[2], x):
# fact: 3 <= x; question: x <= 2 ? --> false iff 2 < 3
if isValue(fact[1]) and isValue(c):
if leValue(c, fact[1].pred): result = impNo
else:result = impUnknown
else:
result = impUnknown
else:
result = impUnknown
of mNot, mOr, mAnd: assert(false, "impliesLe")
else: discard
of mNot, mOr, mAnd:
result = impUnknown
assert(false, "impliesLe")
else: result = impUnknown
proc impliesLt(fact, x, c: PNode): TImplication =
# x < 3 same as x <= 2:
@@ -674,6 +788,8 @@ proc impliesLt(fact, x, c: PNode): TImplication =
let q = x.pred
if q != x:
result = impliesLe(fact, q, c)
else:
result = impUnknown
proc `~`(x: TImplication): TImplication =
case x
@@ -725,6 +841,7 @@ proc factImplies(fact, prop: PNode): TImplication =
proc doesImply*(facts: TModel, prop: PNode): TImplication =
assert prop.kind in nkCallKinds
result = impUnknown
for f in facts.s:
# facts can be invalidated, in which case they are 'nil':
if not f.isNil:
@@ -900,6 +1017,7 @@ proc applyReplacements(n: PNode; rep: TReplacements): PNode =
proc pleViaModelRec(m: var TModel; a, b: PNode): TImplication =
# now check for inferrable facts: a <= b and b <= c implies a <= c
result = impUnknown
for i in 0..m.s.high:
let fact = m.s[i]
if fact != nil and fact.getMagic in someLe:
@@ -981,7 +1099,7 @@ proc addFactLt*(m: var TModel; a, b: PNode) =
proc settype(n: PNode): PType =
result = newType(tySet, ItemId(module: -1, item: -1), n.typ.owner)
var idgen: IdGenerator
var idgen: IdGenerator = nil
addSonSkipIntLit(result, n.typ, idgen)
proc buildOf(it, loc: PNode; o: Operators): PNode =

8
compiler/hlo.nim
View File

@@ -20,9 +20,11 @@ proc evalPattern(c: PContext, n, orig: PNode): PNode =
# we need to ensure that the resulting AST is semchecked. However, it's
# awful to semcheck before macro invocation, so we don't and treat
# templates and macros as immediate in this context.
var rule: string
if c.config.hasHint(hintPattern):
rule = renderTree(n, {renderNoComments})
var rule: string =
if c.config.hasHint(hintPattern):
renderTree(n, {renderNoComments})
else:
""
let s = n[0].sym
case s.kind
of skMacro:

2
compiler/ic/cbackend.nim
View File

@@ -101,7 +101,7 @@ proc aliveSymsChanged(config: ConfigRef; position: int; alive: AliveSyms): bool
var f2 = rodfiles.open(asymFile.string)
f2.loadHeader()
f2.loadSection aliveSymsSection
var oldData: seq[int32]
var oldData: seq[int32] = @[]
f2.loadSeq(oldData)
f2.close
if f2.err == ok and oldData == s:

4
compiler/ic/dce.nim
View File

@@ -40,10 +40,14 @@ proc isExportedToC(c: var AliveContext; g: PackedModuleGraph; symId: int32): boo
if ({sfExportc, sfCompilerProc} * flags != {}) or
(symPtr.kind == skMethod):
result = true
else:
result = false
# XXX: This used to be a condition to:
# (sfExportc in prc.flags and lfExportLib in prc.loc.flags) or
if sfCompilerProc in flags:
c.compilerProcs[g[c.thisModule].fromDisk.strings[symPtr.name]] = (c.thisModule, symId)
else:
result = false
template isNotGeneric(n: NodePos): bool = ithSon(tree, n, genericParamsPos).kind == nkEmpty

9
compiler/ic/ic.nim
View File

@@ -813,6 +813,7 @@ proc loadProcHeader(c: var PackedDecoder; g: var PackedModuleGraph; thisModule:
proc loadProcBody(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
tree: PackedTree; n: NodePos): PNode =
result = nil
var i = 0
for n0 in sonsReadonly(tree, n):
if i == bodyPos:
@@ -1147,6 +1148,8 @@ proc initRodIter*(it: var RodIter; config: ConfigRef, cache: IdentCache;
if it.i < it.values.len:
result = loadSym(it.decoder, g, int(module), it.values[it.i])
inc it.i
else:
result = nil
proc initRodIterAllSyms*(it: var RodIter; config: ConfigRef, cache: IdentCache;
g: var PackedModuleGraph; module: FileIndex, importHidden: bool): PSym =
@@ -1164,11 +1167,15 @@ proc initRodIterAllSyms*(it: var RodIter; config: ConfigRef, cache: IdentCache;
if it.i < it.values.len:
result = loadSym(it.decoder, g, int(module), it.values[it.i])
inc it.i
else:
result = nil
proc nextRodIter*(it: var RodIter; g: var PackedModuleGraph): PSym =
if it.i < it.values.len:
result = loadSym(it.decoder, g, it.module, it.values[it.i])
inc it.i
else:
result = nil
iterator interfaceSymbols*(config: ConfigRef, cache: IdentCache;
g: var PackedModuleGraph; module: FileIndex;
@@ -1201,7 +1208,7 @@ proc searchForCompilerproc*(m: LoadedModule; name: string): int32 =
# ------------------------- .rod file viewer ---------------------------------
proc rodViewer*(rodfile: AbsoluteFile; config: ConfigRef, cache: IdentCache) =
var m: PackedModule
var m: PackedModule = PackedModule()
let err = loadRodFile(rodfile, m, config, ignoreConfig=true)
if err != ok:
config.quitOrRaise "Error: could not load: " & $rodfile.string & " reason: " & $err

6
compiler/ic/navigator.nim
View File

@@ -34,7 +34,11 @@ proc isTracked(current, trackPos: PackedLineInfo, tokenLen: int): bool =
if current.file == trackPos.file and current.line == trackPos.line:
let col = trackPos.col
if col >= current.col and col < current.col+tokenLen:
return true
result = true
else:
result = false
else:
result = false
proc searchLocalSym(c: var NavContext; s: PackedSym; info: PackedLineInfo): bool =
result = s.name != LitId(0) and

1
compiler/ic/packed_ast.nim
View File

@@ -305,6 +305,7 @@ proc sons3*(tree: PackedTree; n: NodePos): (NodePos, NodePos, NodePos) =
result = (NodePos a, NodePos b, NodePos c)
proc ithSon*(tree: PackedTree; n: NodePos; i: int): NodePos =
result = default(NodePos)
if tree.nodes[n.int].kind > nkNilLit:
var count = 0
for child in sonsReadonly(tree, n):

6
compiler/ic/rodfiles.nim
View File

@@ -215,7 +215,7 @@ proc storeHeader*(f: var RodFile) =
proc loadHeader*(f: var RodFile) =
## Loads the header which is described by `cookie`.
if f.err != ok: return
var thisCookie: array[cookie.len, byte]
var thisCookie: array[cookie.len, byte] = default(array[cookie.len, byte])
if f.f.readBytes(thisCookie, 0, thisCookie.len) != thisCookie.len:
setError f, ioFailure
elif thisCookie != cookie:
@@ -231,13 +231,14 @@ proc storeSection*(f: var RodFile; s: RodSection) =
proc loadSection*(f: var RodFile; expected: RodSection) =
## read the bytes value of s, sets and error if the section is incorrect.
if f.err != ok: return
var s: RodSection
var s: RodSection = default(RodSection)
loadPrim(f, s)
if expected != s and f.err == ok:
setError f, wrongSection
proc create*(filename: string): RodFile =
## create the file and open it for writing
result = default(RodFile)
if not open(result.f, filename, fmWrite):
setError result, cannotOpen
@@ -245,5 +246,6 @@ proc close*(f: var RodFile) = close(f.f)
proc open*(filename: string): RodFile =
## open the file for reading
result = default(RodFile)
if not open(result.f, filename, fmRead):
setError result, cannotOpen

3
compiler/importer.nim
View File

@@ -113,6 +113,7 @@ proc rawImportSymbol(c: PContext, s, origin: PSym; importSet: var IntSet) =
proc splitPragmas(c: PContext, n: PNode): (PNode, seq[TSpecialWord]) =
template bail = globalError(c.config, n.info, "invalid pragma")
result = (nil, @[])
if n.kind == nkPragmaExpr:
if n.len == 2 and n[1].kind == nkPragma:
result[0] = n[0]
@@ -307,6 +308,8 @@ proc myImportModule(c: PContext, n: var PNode, importStmtResult: PNode): PSym =
suggestSym(c.graph, n.info, result, c.graph.usageSym, false)
importStmtResult.add newSymNode(result, n.info)
#newStrNode(toFullPath(c.config, f), n.info)
else:
result = nil
proc afterImport(c: PContext, m: PSym) =
# fixes bug #17510, for re-exported symbols

6
compiler/injectdestructors.nim
View File

@@ -432,6 +432,7 @@ proc destructiveMoveVar(n: PNode; c: var Con; s: var Scope): PNode =
proc isCapturedVar(n: PNode): bool =
let root = getRoot(n)
if root != nil: result = root.name.s[0] == ':'
else: result = false
proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
result = newNodeIT(nkStmtListExpr, n.info, n.typ)
@@ -733,7 +734,9 @@ template handleNestedTempl(n, processCall: untyped, willProduceStmt = false,
result[^1] = maybeVoid(n[^1], s)
dec c.inUncheckedAssignSection, inUncheckedAssignSection
else: assert(false)
else:
result = nil
assert(false)
proc pRaiseStmt(n: PNode, c: var Con; s: var Scope): PNode =
if optOwnedRefs in c.graph.config.globalOptions and n[0].kind != nkEmpty:
@@ -1042,6 +1045,7 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
of nkGotoState, nkState, nkAsmStmt:
result = n
else:
result = nil
internalError(c.graph.config, n.info, "cannot inject destructors to node kind: " & $n.kind)
proc sameLocation*(a, b: PNode): bool =

6
compiler/int128.nim
View File

@@ -171,6 +171,7 @@ proc addToHex*(result: var string; arg: Int128) =
i -= 1
proc toHex*(arg: Int128): string =
result = ""
result.addToHex(arg)
proc inc*(a: var Int128, y: uint32 = 1) =
@@ -330,8 +331,8 @@ proc `*`*(a: Int128, b: int32): Int128 =
if b < 0:
result = -result
proc `*=`*(a: var Int128, b: int32): Int128 =
result = result * b
proc `*=`(a: var Int128, b: int32) =
a = a * b
proc makeInt128(high, low: uint64): Int128 =
result.udata[0] = cast[uint32](low)
@@ -360,6 +361,7 @@ proc `*=`*(a: var Int128, b: Int128) =
import bitops
proc fastLog2*(a: Int128): int =
result = 0
if a.udata[3] != 0:
return 96 + fastLog2(a.udata[3])
if a.udata[2] != 0:

7
compiler/isolation_check.nim
View File

@@ -21,6 +21,7 @@ proc canAlias(arg, ret: PType; marker: var IntSet): bool
proc canAliasN(arg: PType; n: PNode; marker: var IntSet): bool =
case n.kind
of nkRecList:
result = false
for i in 0..<n.len:
result = canAliasN(arg, n[i], marker)
if result: return
@@ -36,7 +37,7 @@ proc canAliasN(arg: PType; n: PNode; marker: var IntSet): bool =
else: discard
of nkSym:
result = canAlias(arg, n.sym.typ, marker)
else: discard
else: result = false
proc canAlias(arg, ret: PType; marker: var IntSet): bool =
if containsOrIncl(marker, ret.id):
@@ -56,6 +57,7 @@ proc canAlias(arg, ret: PType; marker: var IntSet): bool =
else:
result = true
of tyTuple:
result = false
for i in 0..<ret.len:
result = canAlias(arg, ret[i], marker)
if result: break
@@ -184,10 +186,12 @@ proc checkIsolate*(n: PNode): bool =
return false
result = true
of nkIfStmt, nkIfExpr:
result = false
for it in n:
result = checkIsolate(it.lastSon)
if not result: break
of nkCaseStmt:
result = false
for i in 1..<n.len:
result = checkIsolate(n[i].lastSon)
if not result: break
@@ -197,6 +201,7 @@ proc checkIsolate*(n: PNode): bool =
result = checkIsolate(n[i].lastSon)
if not result: break
of nkBracket, nkTupleConstr, nkPar:
result = false
for it in n:
result = checkIsolate(it)
if not result: break

119
compiler/jsgen.nim
View File

@@ -219,7 +219,9 @@ proc mapType(typ: PType): TJSTypeKind =
else: result = etyNone
of tyProc: result = etyProc
of tyCstring: result = etyString
of tyConcept, tyIterable: doAssert false
of tyConcept, tyIterable:
result = etyNone
doAssert false
proc mapType(p: PProc; typ: PType): TJSTypeKind =
result = mapType(typ)
@@ -348,6 +350,7 @@ proc isSimpleExpr(p: PProc; n: PNode): bool =
if n[i].kind notin {nkCommentStmt, nkEmpty}: return false
result = isSimpleExpr(p, n.lastSon)
else:
result = false
if n.isAtom:
result = true
@@ -359,7 +362,7 @@ proc getTemp(p: PProc, defineInLocals: bool = true): Rope =
proc genAnd(p: PProc, a, b: PNode, r: var TCompRes) =
assert r.kind == resNone
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
if p.isSimpleExpr(a) and p.isSimpleExpr(b):
gen(p, a, x)
gen(p, b, y)
@@ -386,7 +389,7 @@ proc genAnd(p: PProc, a, b: PNode, r: var TCompRes) =
proc genOr(p: PProc, a, b: PNode, r: var TCompRes) =
assert r.kind == resNone
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
if p.isSimpleExpr(a) and p.isSimpleExpr(b):
gen(p, a, x)
gen(p, b, y)
@@ -474,6 +477,7 @@ const # magic checked op; magic unchecked op;
proc needsTemp(p: PProc; n: PNode): bool =
# check if n contains a call to determine
# if a temp should be made to prevent multiple evals
result = false
if n.kind in nkCallKinds + {nkTupleConstr, nkObjConstr, nkBracket, nkCurly}:
return true
for c in n:
@@ -509,8 +513,8 @@ proc maybeMakeTempAssignable(p: PProc, n: PNode; x: TCompRes): tuple[a, tmp: Rop
elif x.tmpLoc != "" and n.kind == nkBracketExpr:
# genArrayAddr
var
address, index: TCompRes
first: Int128
address, index: TCompRes = default(TCompRes)
first: Int128 = Zero
gen(p, n[0], address)
gen(p, n[1], index)
let (m1, tmp1) = maybeMakeTemp(p, n[0], address)
@@ -542,7 +546,7 @@ template binaryExpr(p: PProc, n: PNode, r: var TCompRes, magic, frmt: string,
# $1 and $2 in the `frmt` string bind to lhs and rhs of the expr,
# if $3 or $4 are present they will be substituted with temps for
# lhs and rhs respectively
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
useMagic(p, magic)
gen(p, n[1], x)
gen(p, n[2], y)
@@ -572,7 +576,7 @@ proc signedTrimmer(size: BiggestInt): string =
proc binaryUintExpr(p: PProc, n: PNode, r: var TCompRes, op: string,
reassign: static[bool] = false) =
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
let size = n[1].typ.skipTypes(abstractRange).size
@@ -611,8 +615,8 @@ template unaryExpr(p: PProc, n: PNode, r: var TCompRes, magic, frmt: string) =
proc arithAux(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
var
x, y: TCompRes
xLoc, yLoc: Rope
x, y: TCompRes = default(TCompRes)
xLoc, yLoc: Rope = ""
let i = ord(optOverflowCheck notin p.options)
useMagic(p, jsMagics[op][i])
if n.len > 2:
@@ -833,7 +837,7 @@ proc arith(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
if mapType(n[1].typ) != etyBaseIndex:
arithAux(p, n, r, op)
else:
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
r.res = "($# == $# && $# == $#)" % [x.address, y.address, x.res, y.res]
@@ -866,7 +870,7 @@ proc genLineDir(p: PProc, n: PNode) =
p.previousFileName = currentFileName
proc genWhileStmt(p: PProc, n: PNode) =
var cond: TCompRes
var cond: TCompRes = default(TCompRes)
internalAssert p.config, isEmptyType(n.typ)
genLineDir(p, n)
inc(p.unique)
@@ -961,6 +965,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
elif it.kind == nkType:
throwObj = it
else:
throwObj = nil
internalError(p.config, n.info, "genTryStmt")
if orExpr != "": orExpr.add("||")
@@ -1001,7 +1006,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
proc genRaiseStmt(p: PProc, n: PNode) =
if n[0].kind != nkEmpty:
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n[0], a)
let typ = skipTypes(n[0].typ, abstractPtrs)
genLineDir(p, n)
@@ -1015,7 +1020,7 @@ proc genRaiseStmt(p: PProc, n: PNode) =
proc genCaseJS(p: PProc, n: PNode, r: var TCompRes) =
var
a, b, cond, stmt: TCompRes
a, b, cond, stmt: TCompRes = default(TCompRes)
genLineDir(p, n)
gen(p, n[0], cond)
let typeKind = skipTypes(n[0].typ, abstractVar).kind
@@ -1149,7 +1154,7 @@ proc genAsmOrEmitStmt(p: PProc, n: PNode) =
if false:
discard
else:
var r: TCompRes
var r = default(TCompRes)
gen(p, it, r)
if it.typ.kind == tyPointer:
@@ -1165,13 +1170,13 @@ proc genAsmOrEmitStmt(p: PProc, n: PNode) =
p.body.add(r.rdLoc)
else:
var r: TCompRes
var r: TCompRes = default(TCompRes)
gen(p, it, r)
p.body.add(r.rdLoc)
p.body.add "\L"
proc genIf(p: PProc, n: PNode, r: var TCompRes) =
var cond, stmt: TCompRes
var cond, stmt: TCompRes = default(TCompRes)
var toClose = 0
if not isEmptyType(n.typ):
r.kind = resVal
@@ -1208,6 +1213,7 @@ proc generateHeader(p: PProc, typ: PType): Rope =
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
@@ -1231,7 +1237,7 @@ proc needsNoCopy(p: PProc; y: PNode): bool =
{tyRef, tyPtr, tyLent, tyVar, tyCstring, tyProc, tyOwned} + IntegralTypes))
proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
var a, b: TCompRes
var a, b: TCompRes = default(TCompRes)
var xtyp = mapType(p, x.typ)
# disable `[]=` for cstring
@@ -1310,7 +1316,7 @@ proc genFastAsgn(p: PProc, n: PNode) =
genAsgnAux(p, n[0], n[1], noCopyNeeded=noCopy)
proc genSwap(p: PProc, n: PNode) =
var a, b: TCompRes
var a, b: TCompRes = default(TCompRes)
gen(p, n[1], a)
gen(p, n[2], b)
var tmp = p.getTemp(false)
@@ -1328,10 +1334,12 @@ proc getFieldPosition(p: PProc; f: PNode): int =
case f.kind
of nkIntLit..nkUInt64Lit: result = int(f.intVal)
of nkSym: result = f.sym.position
else: internalError(p.config, f.info, "genFieldPosition")
else:
result = 0
internalError(p.config, f.info, "genFieldPosition")
proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.typ = etyBaseIndex
let b = if n.kind == nkHiddenAddr: n[0] else: n
gen(p, b[0], a)
@@ -1395,10 +1403,10 @@ proc genCheckedFieldOp(p: PProc, n: PNode, addrTyp: PType, r: var TCompRes) =
internalAssert p.config, disc.kind == skField
if disc.loc.r == "": disc.loc.r = mangleName(p.module, disc)
var setx: TCompRes
var setx: TCompRes = default(TCompRes)
gen(p, checkExpr[1], setx)
var obj: TCompRes
var obj: TCompRes = default(TCompRes)
gen(p, accessExpr[0], obj)
# Avoid evaluating the LHS twice (one to read the discriminant and one to read
# the field)
@@ -1424,8 +1432,8 @@ proc genCheckedFieldOp(p: PProc, n: PNode, addrTyp: PType, r: var TCompRes) =
proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
var
a, b: TCompRes
first: Int128
a, b: TCompRes = default(TCompRes)
first: Int128 = Zero
r.typ = etyBaseIndex
let m = if n.kind == nkHiddenAddr: n[0] else: n
gen(p, m[0], a)
@@ -1672,7 +1680,7 @@ proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
if t == etyObject or it.typ.kind == tyLent:
gen(p, it, r)
else:
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, it, a)
r.kind = a.kind
r.typ = mapType(p, n.typ)
@@ -1689,7 +1697,7 @@ proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
internalError(p.config, n.info, "genDeref")
proc genArgNoParam(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n, a)
if a.typ == etyBaseIndex:
r.res.add(a.address)
@@ -1699,7 +1707,7 @@ proc genArgNoParam(p: PProc, n: PNode, r: var TCompRes) =
r.res.add(a.res)
proc genArg(p: PProc, n: PNode, param: PSym, r: var TCompRes; emitted: ptr int = nil) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n, a)
if skipTypes(param.typ, abstractVar).kind in {tyOpenArray, tyVarargs} and
a.typ == etyBaseIndex:
@@ -1823,7 +1831,7 @@ proc genInfixCall(p: PProc, n: PNode, r: var TCompRes) =
r.address = ""
r.typ = etyNone
r.res.add(".")
var op: TCompRes
var op: TCompRes = default(TCompRes)
gen(p, n[0], op)
r.res.add(op.res)
genArgs(p, n, r, 2)
@@ -1971,7 +1979,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
result.add("}")
if indirect: result = "[$1]" % [result]
of tyObject:
var initList: Rope
var initList: Rope = ""
createObjInitList(p, t, initIntSet(), initList)
result = ("({$1})") % [initList]
if indirect: result = "[$1]" % [result]
@@ -1998,7 +2006,7 @@ template returnType: untyped = ""
proc genVarInit(p: PProc, v: PSym, n: PNode) =
var
a: TCompRes
a: TCompRes = default(TCompRes)
s: Rope
varCode: string
varName = mangleName(p.module, v)
@@ -2099,7 +2107,7 @@ proc genConstant(p: PProc, c: PSym) =
p.body = oldBody
proc genNew(p: PProc, n: PNode) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n[1], a)
var t = skipTypes(n[1].typ, abstractVar)[0]
if mapType(t) == etyObject:
@@ -2110,7 +2118,7 @@ proc genNew(p: PProc, n: PNode) =
lineF(p, "$1 = [[$2], 0];$n", [a.rdLoc, createVar(p, t, false)])
proc genNewSeq(p: PProc, n: PNode) =
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
let t = skipTypes(n[1].typ, abstractVar)[0]
@@ -2128,7 +2136,7 @@ proc genOrd(p: PProc, n: PNode, r: var TCompRes) =
else: internalError(p.config, n.info, "genOrd")
proc genConStrStr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n[1], a)
r.kind = resExpr
@@ -2153,7 +2161,7 @@ proc genConStrStr(p: PProc, n: PNode, r: var TCompRes) =
proc genReprAux(p: PProc, n: PNode, r: var TCompRes, magic: string, typ: Rope = "") =
useMagic(p, magic)
r.res.add(magic & "(")
var a: TCompRes
var a: TCompRes = default(TCompRes)
gen(p, n[1], a)
if magic == "reprAny":
@@ -2200,7 +2208,7 @@ proc genRepr(p: PProc, n: PNode, r: var TCompRes) =
r.kind = resExpr
proc genOf(p: PProc, n: PNode, r: var TCompRes) =
var x: TCompRes
var x: TCompRes = default(TCompRes)
let t = skipTypes(n[2].typ,
abstractVarRange+{tyRef, tyPtr, tyLent, tyTypeDesc, tyOwned})
gen(p, n[1], x)
@@ -2216,7 +2224,7 @@ proc genDefault(p: PProc, n: PNode; r: var TCompRes) =
r.kind = resExpr
proc genReset(p: PProc, n: PNode) =
var x: TCompRes
var x: TCompRes = default(TCompRes)
useMagic(p, "genericReset")
gen(p, n[1], x)
if x.typ == etyBaseIndex:
@@ -2227,7 +2235,7 @@ proc genReset(p: PProc, n: PNode) =
genTypeInfo(p, n[1].typ), tmp])
proc genMove(p: PProc; n: PNode; r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.kind = resVal
r.res = p.getTemp()
gen(p, n[1], a)
@@ -2236,14 +2244,14 @@ proc genMove(p: PProc; n: PNode; r: var TCompRes) =
#lineF(p, "$1 = $2;$n", [dest.rdLoc, src.rdLoc])
proc genDup(p: PProc; n: PNode; r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.kind = resVal
r.res = p.getTemp()
gen(p, n[1], a)
lineF(p, "$1 = $2;$n", [r.rdLoc, a.rdLoc])
proc genJSArrayConstr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.res = rope("[")
r.kind = resExpr
for i in 0 ..< n.len:
@@ -2274,7 +2282,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
binaryExpr(p, n, r, "addChar",
"addChar($1, $2);")
of mAppendStrStr:
var lhs, rhs: TCompRes
var lhs, rhs: TCompRes = default(TCompRes)
gen(p, n[1], lhs)
gen(p, n[2], rhs)
@@ -2287,7 +2295,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
r.res = "$1.push.apply($3, $2);" % [a, rhs.rdLoc, tmp]
r.kind = resExpr
of mAppendSeqElem:
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
if mapType(n[2].typ) == etyBaseIndex:
@@ -2315,7 +2323,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
if mapType(n[1].typ) != etyBaseIndex:
unaryExpr(p, n, r, "", "($1 == null)")
else:
var x: TCompRes
var x: TCompRes = default(TCompRes)
gen(p, n[1], x)
r.res = "($# == null && $# === 0)" % [x.address, x.res]
of mEnumToStr: genRepr(p, n, r)
@@ -2326,7 +2334,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
if n[1].kind == nkBracket:
genJSArrayConstr(p, n[1], r)
else:
var x: TCompRes
var x: TCompRes = default(TCompRes)
gen(p, n[1], x)
useMagic(p, "nimCopy")
r.res = "nimCopy(null, $1, $2)" % [x.rdLoc, genTypeInfo(p, n.typ)]
@@ -2335,7 +2343,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
of mDestroy, mTrace: discard "ignore calls to the default destructor"
of mOrd: genOrd(p, n, r)
of mLengthStr, mLengthSeq, mLengthOpenArray, mLengthArray:
var x: TCompRes
var x: TCompRes = default(TCompRes)
gen(p, n[1], x)
if skipTypes(n[1].typ, abstractInst).kind == tyCstring:
let (a, tmp) = maybeMakeTemp(p, n[1], x)
@@ -2344,7 +2352,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
r.res = "($1).length" % [x.rdLoc]
r.kind = resExpr
of mHigh:
var x: TCompRes
var x: TCompRes = default(TCompRes)
gen(p, n[1], x)
if skipTypes(n[1].typ, abstractInst).kind == tyCstring:
let (a, tmp) = maybeMakeTemp(p, n[1], x)
@@ -2389,7 +2397,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
"""if ($1.length < $2) { for (var i = $3.length; i < $4; ++i) $3.push(0); }
else {$3.length = $4; }""")
of mSetLengthSeq:
var x, y: TCompRes
var x, y: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
let t = skipTypes(n[1].typ, abstractVar)[0]
@@ -2428,7 +2436,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
genCall(p, n, r)
of mSlice:
# arr.slice([begin[, end]]): 'end' is exclusive
var x, y, z: TCompRes
var x, y, z: TCompRes = default(TCompRes)
gen(p, n[1], x)
gen(p, n[2], y)
gen(p, n[3], z)
@@ -2446,7 +2454,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
proc genSetConstr(p: PProc, n: PNode, r: var TCompRes) =
var
a, b: TCompRes
a, b: TCompRes = default(TCompRes)
useMagic(p, "setConstr")
r.res = rope("setConstr(")
r.kind = resExpr
@@ -2483,7 +2491,7 @@ proc genArrayConstr(p: PProc, n: PNode, r: var TCompRes) =
# generate typed array
# for example Nim generates `new Uint8Array([1, 2, 3])` for `[byte(1), 2, 3]`
# TODO use `set` or loop to initialize typed array which improves performances in some situations
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.res = "new $1([" % [rope(jsTyp)]
r.kind = resExpr
for i in 0 ..< n.len:
@@ -2495,7 +2503,7 @@ proc genArrayConstr(p: PProc, n: PNode, r: var TCompRes) =
genJSArrayConstr(p, n, r)
proc genTupleConstr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.res = rope("{")
r.kind = resExpr
for i in 0..<n.len:
@@ -2514,9 +2522,9 @@ proc genTupleConstr(p: PProc, n: PNode, r: var TCompRes) =
r.res.add("}")
proc genObjConstr(p: PProc, n: PNode, r: var TCompRes) =
var a: TCompRes
var a: TCompRes = default(TCompRes)
r.kind = resExpr
var initList : Rope
var initList : Rope = ""
var fieldIDs = initIntSet()
let nTyp = n.typ.skipTypes(abstractInst)
for i in 1..<n.len:
@@ -2590,7 +2598,7 @@ proc upConv(p: PProc, n: PNode, r: var TCompRes) =
gen(p, n[0], r) # XXX
proc genRangeChck(p: PProc, n: PNode, r: var TCompRes, magic: string) =
var a, b: TCompRes
var a, b: TCompRes = default(TCompRes)
gen(p, n[0], r)
let src = skipTypes(n[0].typ, abstractVarRange)
let dest = skipTypes(n.typ, abstractVarRange)
@@ -2683,9 +2691,10 @@ proc optionalLine(p: Rope): Rope =
proc genProc(oldProc: PProc, prc: PSym): Rope =
## Generate a JS procedure ('function').
result = ""
var
resultSym: PSym
a: TCompRes
a: TCompRes = default(TCompRes)
#if gVerbosity >= 3:
# echo "BEGIN generating code for: " & prc.name.s
var p = newProc(oldProc.g, oldProc.module, prc.ast, prc.options)
@@ -2765,7 +2774,7 @@ proc genProc(oldProc: PProc, prc: PSym): Rope =
# echo "END generated code for: " & prc.name.s
proc genStmt(p: PProc, n: PNode) =
var r: TCompRes
var r: TCompRes = default(TCompRes)
gen(p, n, r)
if r.res != "": lineF(p, "$#;$n", [r.res])

7
compiler/lambdalifting.nim
View File

@@ -187,6 +187,8 @@ proc getEnvParam*(routine: PSym): PSym =
if hidden.kind == nkSym and hidden.sym.name.s == paramName:
result = hidden.sym
assert sfFromGeneric in result.flags
else:
result = nil
proc interestingVar(s: PSym): bool {.inline.} =
result = s.kind in {skVar, skLet, skTemp, skForVar, skParam, skResult} and
@@ -199,6 +201,8 @@ proc illegalCapture(s: PSym): bool {.inline.} =
proc isInnerProc(s: PSym): bool =
if s.kind in {skProc, skFunc, skMethod, skConverter, skIterator} and s.magic == mNone:
result = s.skipGenericOwner.kind in routineKinds
else:
result = false
proc newAsgnStmt(le, ri: PNode, info: TLineInfo): PNode =
# Bugfix: unfortunately we cannot use 'nkFastAsgn' here as that would
@@ -711,6 +715,7 @@ proc symToClosure(n: PNode; owner: PSym; d: var DetectionPass;
# direct dependency, so use the outer's env variable:
result = makeClosure(d.graph, d.idgen, s, setupEnvVar(owner, d, c, n.info), n.info)
else:
result = nil
let available = getHiddenParam(d.graph, owner)
let wanted = getHiddenParam(d.graph, s).typ
# ugh: call through some other inner proc;
@@ -936,7 +941,7 @@ proc liftForLoop*(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner: PSym):
result = newNodeI(nkStmtList, body.info)
# static binding?
var env: PSym
var env: PSym = nil
let op = call[0]
if op.kind == nkSym and op.sym.isIterator:
# createClosure()

18
compiler/lexer.nim
View File

@@ -148,9 +148,11 @@ proc isNimIdentifier*(s: string): bool =
var i = 1
while i < sLen:
if s[i] == '_': inc(i)
if i < sLen and s[i] notin SymChars: return
if i < sLen and s[i] notin SymChars: return false
inc(i)
result = true
else:
result = false
proc `$`*(tok: Token): string =
case tok.tokType
@@ -537,8 +539,8 @@ proc getNumber(L: var Lexer, result: var Token) =
of floatTypes:
result.fNumber = parseFloat(result.literal)
of tkUInt64Lit, tkUIntLit:
var iNumber: uint64
var len: int
var iNumber: uint64 = uint64(0)
var len: int = 0
try:
len = parseBiggestUInt(result.literal, iNumber)
except ValueError:
@@ -547,8 +549,8 @@ proc getNumber(L: var Lexer, result: var Token) =
raise newException(ValueError, "invalid integer: " & result.literal)
result.iNumber = cast[int64](iNumber)
else:
var iNumber: int64
var len: int
var iNumber: int64 = int64(0)
var len: int = 0
try:
len = parseBiggestInt(result.literal, iNumber)
except ValueError:
@@ -1007,6 +1009,7 @@ proc getPrecedence*(tok: Token): int =
else: return -10
proc newlineFollows*(L: Lexer): bool =
result = false
var pos = L.bufpos
while true:
case L.buf[pos]
@@ -1394,8 +1397,9 @@ proc rawGetTok*(L: var Lexer, tok: var Token) =
proc getIndentWidth*(fileIdx: FileIndex, inputstream: PLLStream;
cache: IdentCache; config: ConfigRef): int =
var lex: Lexer
var tok: Token
result = 0
var lex: Lexer = default(Lexer)
var tok: Token = default(Token)
initToken(tok)
openLexer(lex, fileIdx, inputstream, cache, config)
var prevToken = tkEof

14
compiler/liftdestructors.nim
View File

@@ -367,6 +367,8 @@ proc considerAsgnOrSink(c: var TLiftCtx; t: PType; body, x, y: PNode;
op = produceSym(c.g, c.c, t, c.kind, c.info, c.idgen)
body.add newHookCall(c, op, x, y)
result = true
else:
result = false
elif tfHasAsgn in t.flags:
var op: PSym
if sameType(t, c.asgnForType):
@@ -396,6 +398,8 @@ proc considerAsgnOrSink(c: var TLiftCtx; t: PType; body, x, y: PNode;
assert op.ast[genericParamsPos].kind == nkEmpty
body.add newHookCall(c, op, x, y)
result = true
else:
result = false
proc addDestructorCall(c: var TLiftCtx; orig: PType; body, x: PNode) =
let t = orig.skipTypes(abstractInst - {tyDistinct})
@@ -435,6 +439,8 @@ proc considerUserDefinedOp(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
onUse(c.info, op)
body.add destructorCall(c, op, x)
result = true
else:
result = false
#result = addDestructorCall(c, t, body, x)
of attachedAsgn, attachedSink, attachedTrace:
var op = getAttachedOp(c.g, t, c.kind)
@@ -455,6 +461,8 @@ proc considerUserDefinedOp(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
onUse(c.info, op)
body.add newDeepCopyCall(c, op, x, y)
result = true
else:
result = false
of attachedWasMoved:
var op = getAttachedOp(c.g, t, attachedWasMoved)
@@ -469,6 +477,8 @@ proc considerUserDefinedOp(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
onUse(c.info, op)
body.add genWasMovedCall(c, op, x)
result = true
else:
result = false
of attachedDup:
var op = getAttachedOp(c.g, t, attachedDup)
@@ -483,6 +493,8 @@ proc considerUserDefinedOp(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
onUse(c.info, op)
body.add newDupCall(c, op, x, y)
result = true
else:
result = false
proc declareCounter(c: var TLiftCtx; body: PNode; first: BiggestInt): PNode =
var temp = newSym(skTemp, getIdent(c.g.cache, lowerings.genPrefix), c.idgen, c.fn, c.info)
@@ -1249,7 +1261,7 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
# bug #15122: We need to produce all prototypes before entering the
# mind boggling recursion. Hacks like these imply we should rewrite
# this module.
var generics: array[attachedWasMoved..attachedTrace, bool]
var generics: array[attachedWasMoved..attachedTrace, bool] = default(array[attachedWasMoved..attachedTrace, bool])
for k in attachedWasMoved..lastAttached:
generics[k] = getAttachedOp(g, canon, k) != nil
if not generics[k]:

1
compiler/liftlocals.nim
View File

@@ -49,6 +49,7 @@ proc liftLocals(n: PNode; i: int; c: var Ctx) =
liftLocals(it, i, c)
proc lookupParam(params, dest: PNode): PSym =
result = nil
if dest.kind != nkIdent: return nil
for i in 1..<params.len:
if params[i].kind == nkSym and params[i].sym.name.id == dest.ident.id:

2
compiler/lineinfos.nim
View File

@@ -310,7 +310,7 @@ proc `==`*(a, b: FileIndex): bool {.borrow.}
proc hash*(i: TLineInfo): Hash =
hash (i.line.int, i.col.int, i.fileIndex.int)
proc raiseRecoverableError*(msg: string) {.noinline.} =
proc raiseRecoverableError*(msg: string) {.noinline, noreturn.} =
raise newException(ERecoverableError, msg)
const

2
compiler/linter.nim
View File

@@ -19,10 +19,12 @@ const
Letters* = {'a'..'z', 'A'..'Z', '0'..'9', '\x80'..'\xFF', '_'}
proc identLen*(line: string, start: int): int =
result = 0
while start+result < line.len and line[start+result] in Letters:
inc result
proc `=~`(s: string, a: openArray[string]): bool =
result = false
for x in a:
if s.startsWith(x): return true

3
compiler/llstream.nim
View File

@@ -78,6 +78,8 @@ proc endsWith*(x: string, s: set[char]): bool =
while i >= 0 and x[i] == ' ': dec(i)
if i >= 0 and x[i] in s:
result = true
else:
result = false
const
LineContinuationOprs = {'+', '-', '*', '/', '\\', '<', '>', '!', '?', '^',
@@ -93,6 +95,7 @@ proc continueLine(line: string, inTripleString: bool): bool {.inline.} =
line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs))
proc countTriples(s: string): int =
result = 0
var i = 0
while i+2 < s.len:
if s[i] == '"' and s[i+1] == '"' and s[i+2] == '"':

20
compiler/lookups.nim
View File

@@ -298,7 +298,7 @@ proc ensureNoMissingOrUnusedSymbols(c: PContext; scope: PScope) =
var it: TTabIter
var s = initTabIter(it, scope.symbols)
var missingImpls = 0
var unusedSyms: seq[tuple[sym: PSym, key: string]]
var unusedSyms: seq[tuple[sym: PSym, key: string]] = @[]
while s != nil:
if sfForward in s.flags and s.kind notin {skType, skModule}:
# too many 'implementation of X' errors are annoying
@@ -458,7 +458,7 @@ proc fixSpelling(c: PContext, n: PNode, ident: PIdent, result: var string) =
for (sym, depth, isLocal) in allSyms(c):
let depth = -depth - 1
let dist = editDistance(name0, sym.name.s.nimIdentNormalize)
var msg: string
var msg: string = ""
msg.add "\n ($1, $2): '$3'" % [$dist, $depth, sym.name.s]
list.push SpellCandidate(dist: dist, depth: depth, msg: msg, sym: sym)
@@ -488,6 +488,7 @@ proc errorUseQualifier(c: PContext; info: TLineInfo; s: PSym; amb: var bool): PS
var err = "ambiguous identifier: '" & s.name.s & "'"
var i = 0
var ignoredModules = 0
result = nil
for candidate in importedItems(c, s.name):
if i == 0: err.add " -- use one of the following:\n"
else: err.add "\n"
@@ -586,6 +587,8 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
amb = candidates.len > 1
if amb and checkAmbiguity in flags:
errorUseQualifier(c, n.info, candidates)
else:
result = nil
if result == nil:
let candidates = allPureEnumFields(c, ident)
if candidates.len > 0:
@@ -641,6 +644,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
o.marked = initIntSet()
case n.kind
of nkIdent, nkAccQuoted:
result = nil
var ident = considerQuotedIdent(c, n)
var scope = c.currentScope
o.mode = oimNoQualifier
@@ -664,6 +668,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
result = n.sym
o.mode = oimDone
of nkDotExpr:
result = nil
o.mode = oimOtherModule
o.m = qualifiedLookUp(c, n[0], {checkUndeclared, checkModule})
if o.m != nil and o.m.kind == skModule:
@@ -693,7 +698,7 @@ proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
o.symChoiceIndex = 1
o.marked = initIntSet()
incl(o.marked, result.id)
else: discard
else: result = nil
when false:
if result != nil and result.kind == skStub: loadStub(result)
@@ -708,6 +713,7 @@ proc lastOverloadScope*(o: TOverloadIter): int =
else: result = -1
proc nextOverloadIterImports(o: var TOverloadIter, c: PContext, n: PNode): PSym =
result = nil
assert o.currentScope == nil
var idx = o.importIdx+1
o.importIdx = c.imports.len # assume the other imported modules lack this symbol too
@@ -720,6 +726,7 @@ proc nextOverloadIterImports(o: var TOverloadIter, c: PContext, n: PNode): PSym
inc idx
proc symChoiceExtension(o: var TOverloadIter; c: PContext; n: PNode): PSym =
result = nil
assert o.currentScope == nil
while o.importIdx < c.imports.len:
result = initIdentIter(o.mit, o.marked, c.imports[o.importIdx], o.it.name, c.graph)
@@ -782,6 +789,8 @@ proc nextOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
break
if result != nil:
incl o.marked, result.id
else:
result = nil
of oimSymChoiceLocalLookup:
if o.currentScope != nil:
result = nextIdentExcluding(o.it, o.currentScope.symbols, o.marked)
@@ -805,13 +814,16 @@ proc nextOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
if result == nil:
inc o.importIdx
result = symChoiceExtension(o, c, n)
else:
result = nil
when false:
if result != nil and result.kind == skStub: loadStub(result)
proc pickSym*(c: PContext, n: PNode; kinds: set[TSymKind];
flags: TSymFlags = {}): PSym =
var o: TOverloadIter
result = nil
var o: TOverloadIter = default(TOverloadIter)
var a = initOverloadIter(o, c, n)
while a != nil:
if a.kind in kinds and flags <= a.flags:

2
compiler/magicsys.nim
View File

@@ -30,6 +30,7 @@ proc getSysSym*(g: ModuleGraph; info: TLineInfo; name: string): PSym =
result.typ = newType(tyError, nextTypeId(g.idgen), g.systemModule)
proc getSysMagic*(g: ModuleGraph; info: TLineInfo; name: string, m: TMagic): PSym =
result = nil
let id = getIdent(g.cache, name)
for r in systemModuleSyms(g, id):
if r.magic == m:
@@ -145,6 +146,7 @@ proc getMagicEqSymForType*(g: ModuleGraph; t: PType; info: TLineInfo): PSym =
of tyProc:
result = getSysMagic(g, info, "==", mEqProc)
else:
result = nil
globalError(g.config, info,
"can't find magic equals operator for type kind " & $t.kind)

4
compiler/main.nim
View File

@@ -56,7 +56,7 @@ proc writeCMakeDepsFile(conf: ConfigRef) =
for it in conf.toCompile: cfiles.add(it.cname.string)
let fileset = cfiles.toCountTable()
# read old cfiles list
var fl: File
var fl: File = default(File)
var prevset = initCountTable[string]()
if open(fl, fname.string, fmRead):
for line in fl.lines: prevset.inc(line)
@@ -196,7 +196,7 @@ proc commandScan(cache: IdentCache, config: ConfigRef) =
if stream != nil:
var
L: Lexer
tok: Token
tok: Token = default(Token)
initToken(tok)
openLexer(L, f, stream, cache, config)
while true:

6
compiler/modulegraphs.nim
View File

@@ -368,6 +368,7 @@ proc copyTypeProps*(g: ModuleGraph; module: int; dest, src: PType) =
setAttachedOp(g, module, dest, k, op)
proc loadCompilerProc*(g: ModuleGraph; name: string): PSym =
result = nil
if g.config.symbolFiles == disabledSf: return nil
# slow, linear search, but the results are cached:
@@ -500,6 +501,7 @@ proc resetAllModules*(g: ModuleGraph) =
initModuleGraphFields(g)
proc getModule*(g: ModuleGraph; fileIdx: FileIndex): PSym =
result = nil
if fileIdx.int32 >= 0:
if isCachedModule(g, fileIdx.int32):
result = g.packed[fileIdx.int32].module
@@ -605,6 +607,7 @@ proc markClientsDirty*(g: ModuleGraph; fileIdx: FileIndex) =
proc needsCompilation*(g: ModuleGraph): bool =
# every module that *depends* on this file is also dirty:
result = false
for i in 0i32..<g.ifaces.len.int32:
let m = g.ifaces[i].module
if m != nil:
@@ -612,6 +615,7 @@ proc needsCompilation*(g: ModuleGraph): bool =
return true
proc needsCompilation*(g: ModuleGraph, fileIdx: FileIndex): bool =
result = false
let module = g.getModule(fileIdx)
if module != nil and g.isDirty(module):
return true
@@ -633,6 +637,8 @@ proc moduleFromRodFile*(g: ModuleGraph; fileIdx: FileIndex;
## Returns 'nil' if the module needs to be recompiled.
if g.config.symbolFiles in {readOnlySf, v2Sf, stressTest}:
result = moduleFromRodFile(g.packed, g.config, g.cache, fileIdx, cachedModules)
else:
result = nil
proc configComplete*(g: ModuleGraph) =
rememberStartupConfig(g.startupPackedConfig, g.config)

6
compiler/msgs.nim
View File

@@ -294,9 +294,11 @@ proc toColumn*(info: TLineInfo): int {.inline.} =
result = info.col
proc toFileLineCol(info: InstantiationInfo): string {.inline.} =
result = ""
result.toLocation(info.filename, info.line, info.column + ColOffset)
proc toFileLineCol*(conf: ConfigRef; info: TLineInfo): string {.inline.} =
result = ""
result.toLocation(toMsgFilename(conf, info), info.line.int, info.col.int + ColOffset)
proc `$`*(conf: ConfigRef; info: TLineInfo): string = toFileLineCol(conf, info)
@@ -408,7 +410,7 @@ proc getMessageStr(msg: TMsgKind, arg: string): string = msgKindToString(msg) %
type TErrorHandling* = enum doNothing, doAbort, doRaise
proc log*(s: string) =
var f: File
var f: File = default(File)
if open(f, getHomeDir() / "nimsuggest.log", fmAppend):
f.writeLine(s)
close(f)
@@ -502,6 +504,8 @@ proc getSurroundingSrc(conf: ConfigRef; info: TLineInfo): string =
result = "\n" & indent & $sourceLine(conf, info)
if info.col >= 0:
result.add "\n" & indent & spaces(info.col) & '^'
else:
result = ""
proc formatMsg*(conf: ConfigRef; info: TLineInfo, msg: TMsgKind, arg: string): string =
let title = case msg

18
compiler/nilcheck.nim
View File

@@ -309,6 +309,7 @@ proc symbol(n: PNode): Symbol =
# echo "symbol ", n, " ", n.kind, " ", result.int
func `$`(map: NilMap): string =
result = ""
var now = map
var stack: seq[NilMap] = @[]
while not now.isNil:
@@ -416,7 +417,7 @@ proc moveOut(ctx: NilCheckerContext, map: NilMap, target: PNode) =
if targetSetIndex != noSetIndex:
var targetSet = map.sets[targetSetIndex]
if targetSet.len > 1:
var other: ExprIndex
var other: ExprIndex = default(ExprIndex)
for element in targetSet:
if element.ExprIndex != targetIndex:
@@ -561,7 +562,7 @@ proc derefWarning(n, ctx, map; kind: Nilability) =
if n.info in ctx.warningLocations:
return
ctx.warningLocations.incl(n.info)
var a: seq[History]
var a: seq[History] = @[]
if n.kind == nkSym:
a = history(map, ctx.index(n))
var res = ""
@@ -765,7 +766,7 @@ proc checkIf(n, ctx, map): Check =
# the state of the conditions: negating conditions before the current one
var layerHistory = newNilMap(mapIf)
# the state after branch effects
var afterLayer: NilMap
var afterLayer: NilMap = nil
# the result nilability for expressions
var nilability = Safe
@@ -862,9 +863,10 @@ proc checkInfix(n, ctx, map): Check =
## a or b : map is an union of a and b's
## a == b : use checkCondition
## else: no change, just check args
result = default(Check)
if n[0].kind == nkSym:
var mapL: NilMap
var mapR: NilMap
var mapL: NilMap = nil
var mapR: NilMap = nil
if n[0].sym.magic notin {mAnd, mEqRef}:
mapL = checkCondition(n[1], ctx, map, false, false)
mapR = checkCondition(n[2], ctx, map, false, false)
@@ -947,7 +949,7 @@ proc checkCase(n, ctx, map): Check =
let base = n[0]
result.map = map.copyMap()
result.nilability = Safe
var a: PNode
var a: PNode = nil
for child in n:
case child.kind:
of nkOfBranch:
@@ -1222,7 +1224,7 @@ proc check(n: PNode, ctx: NilCheckerContext, map: NilMap): Check =
# TODO deeper nested elements?
# A(field: B()) #
# field: Safe ->
var elements: seq[(PNode, Nilability)]
var elements: seq[(PNode, Nilability)] = @[]
for i, child in n:
result = check(child, ctx, result.map)
if i > 0:
@@ -1333,7 +1335,7 @@ proc preVisit(ctx: NilCheckerContext, s: PSym, body: PNode, conf: ConfigRef) =
ctx.symbolIndices = {resultId: resultExprIndex}.toTable()
var cache = newIdentCache()
ctx.expressions = SeqOfDistinct[ExprIndex, PNode](@[newIdentNode(cache.getIdent("result"), s.ast.info)])
var emptySet: IntSet # set[ExprIndex]
var emptySet: IntSet = initIntSet() # set[ExprIndex]
ctx.dependants = SeqOfDistinct[ExprIndex, IntSet](@[emptySet])
for i, arg in s.typ.n.sons:
if i > 0:

7
compiler/nim.cfg
View File

@@ -43,3 +43,10 @@ define:useStdoutAsStdmsg
@if nimHasWarnBareExcept:
warningAserror[BareExcept]:on
@end
@if nimUseStrictDefs:
experimental:strictDefs
warningAsError[Uninit]:on
warningAsError[ProveInit]:on
@end

3
compiler/nim.nim
View File

@@ -91,6 +91,9 @@ proc getNimRunExe(conf: ConfigRef): string =
if conf.isDefined("mingw"):
if conf.isDefined("i386"): result = "wine"
elif conf.isDefined("amd64"): result = "wine64"
else: result = ""
else:
result = ""
proc handleCmdLine(cache: IdentCache; conf: ConfigRef) =
let self = NimProg(

11
compiler/nimblecmd.nim
View File

@@ -37,11 +37,16 @@ proc isSpecial(ver: Version): bool =
proc isValidVersion(v: string): bool =
if v.len > 0:
if v[0] in {'#'} + Digits: return true
if v[0] in {'#'} + Digits:
result = true
else:
result = false
else:
result = false
proc `<`*(ver: Version, ver2: Version): bool =
## This is synced from Nimble's version module.
result = false
# Handling for special versions such as "#head" or "#branch".
if ver.isSpecial or ver2.isSpecial:
if ver2.isSpecial and ($ver2).normalize == "#head":
@@ -145,7 +150,7 @@ proc addNimblePath(conf: ConfigRef; p: string, info: TLineInfo) =
conf.lazyPaths.insert(AbsoluteDir path, 0)
proc addPathRec(conf: ConfigRef; dir: string, info: TLineInfo) =
var packages: PackageInfo
var packages: PackageInfo = initTable[string, tuple[version, checksum: string]]()
var pos = dir.len-1
if dir[pos] in {DirSep, AltSep}: inc(pos)
for k,p in os.walkDir(dir):

6
compiler/nimconf.nim
View File

@@ -214,7 +214,7 @@ proc parseAssignment(L: var Lexer, tok: var Token;
proc readConfigFile*(filename: AbsoluteFile; cache: IdentCache;
config: ConfigRef): bool =
var
L: Lexer
L: Lexer = default(Lexer)
tok: Token
stream: PLLStream
stream = llStreamOpen(filename, fmRead)
@@ -228,6 +228,8 @@ proc readConfigFile*(filename: AbsoluteFile; cache: IdentCache;
if condStack.len > 0: lexMessage(L, errGenerated, "expected @end")
closeLexer(L)
return true
else:
result = false
proc getUserConfigPath*(filename: RelativeFile): AbsoluteFile =
result = getConfigDir().AbsoluteDir / RelativeDir"nim" / filename
@@ -250,7 +252,7 @@ proc loadConfigs*(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef; idgen:
template runNimScriptIfExists(path: AbsoluteFile, isMain = false) =
let p = path # eval once
var s: PLLStream
var s: PLLStream = nil
if isMain and optWasNimscript in conf.globalOptions:
if conf.projectIsStdin: s = stdin.llStreamOpen
elif conf.projectIsCmd: s = llStreamOpen(conf.cmdInput)

4
compiler/nimsets.nim
View File

@@ -62,7 +62,9 @@ proc someInSet*(s: PNode, a, b: PNode): bool =
result = false
proc toBitSet*(conf: ConfigRef; s: PNode): TBitSet =
var first, j: Int128
result = @[]
var first: Int128 = Zero
var j: Int128 = Zero
first = firstOrd(conf, s.typ[0])
bitSetInit(result, int(getSize(conf, s.typ)))
for i in 0..<s.len:

2
compiler/optimizer.nim
View File

@@ -279,7 +279,7 @@ proc optimize*(n: PNode): PNode =
Now assume 'use' raises, then we shouldn't do the 'wasMoved(s)'
]#
var c: Con
var c: Con = Con()
var b: BasicBlock
analyse(c, b, n)
if c.somethingTodo:

5
compiler/options.nim
View File

@@ -421,6 +421,7 @@ type
proc parseNimVersion*(a: string): NimVer =
# could be moved somewhere reusable
result = default(NimVer)
if a.len > 0:
let b = a.split(".")
assert b.len == 3, a
@@ -657,7 +658,7 @@ proc isDefined*(conf: ConfigRef; symbol: string): bool =
of "nimrawsetjmp":
result = conf.target.targetOS in {osSolaris, osNetbsd, osFreebsd, osOpenbsd,
osDragonfly, osMacosx}
else: discard
else: result = false
template quitOrRaise*(conf: ConfigRef, msg = "") =
# xxx in future work, consider whether to also intercept `msgQuit` calls
@@ -883,6 +884,7 @@ const
stdPrefix = "std/"
proc getRelativePathFromConfigPath*(conf: ConfigRef; f: AbsoluteFile, isTitle = false): RelativeFile =
result = RelativeFile("")
let f = $f
if isTitle:
for dir in stdlibDirs:
@@ -918,6 +920,7 @@ proc findModule*(conf: ConfigRef; modulename, currentModule: string): AbsoluteFi
result = findFile(conf, m.substr(pkgPrefix.len), suppressStdlib = true)
else:
if m.startsWith(stdPrefix):
result = AbsoluteFile("")
let stripped = m.substr(stdPrefix.len)
for candidate in stdlibDirs:
let path = (conf.libpath.string / candidate / stripped)

1
compiler/packagehandling.nim
View File

@@ -17,6 +17,7 @@ iterator myParentDirs(p: string): string =
proc getNimbleFile*(conf: ConfigRef; path: string): string =
## returns absolute path to nimble file, e.g.: /pathto/cligen.nimble
result = ""
var parents = 0
block packageSearch:
for d in myParentDirs(path):

1
compiler/parampatterns.nim
View File

@@ -184,6 +184,7 @@ type
arStrange # it is a strange beast like 'typedesc[var T]'
proc exprRoot*(n: PNode; allowCalls = true): PSym =
result = nil
var it = n
while true:
case it.kind

2
compiler/parser.nim
View File

@@ -1177,6 +1177,7 @@ proc optPragmas(p: var Parser): PNode =
proc parseDoBlock(p: var Parser; info: TLineInfo): PNode =
#| doBlock = 'do' paramListArrow pragma? colcom stmt
result = nil
var params = parseParamList(p, retColon=false)
let pragmas = optPragmas(p)
colcom(p, result)
@@ -1430,6 +1431,7 @@ proc parseTypeDesc(p: var Parser, fullExpr = false): PNode =
result = newNodeP(nkObjectTy, p)
getTok(p)
of tkConcept:
result = nil
parMessage(p, "the 'concept' keyword is only valid in 'type' sections")
of tkVar: result = parseTypeDescKAux(p, nkVarTy, pmTypeDesc)
of tkOut: result = parseTypeDescKAux(p, nkOutTy, pmTypeDesc)

40
compiler/patterns.nim
View File

@@ -29,6 +29,8 @@ type
proc getLazy(c: PPatternContext, sym: PSym): PNode =
if c.mappingIsFull:
result = c.mapping[sym.position]
else:
result = nil
proc putLazy(c: PPatternContext, sym: PSym, n: PNode) =
if not c.mappingIsFull:
@@ -65,14 +67,21 @@ proc sameTrees*(a, b: PNode): bool =
for i in 0..<a.len:
if not sameTrees(a[i], b[i]): return
result = true
else:
result = false
else:
result = false
proc inSymChoice(sc, x: PNode): bool =
if sc.kind == nkClosedSymChoice:
result = false
for i in 0..<sc.len:
if sc[i].sym == x.sym: return true
elif sc.kind == nkOpenSymChoice:
# same name suffices for open sym choices!
result = sc[0].sym.name.id == x.sym.name.id
else:
result = false
proc checkTypes(c: PPatternContext, p: PSym, n: PNode): bool =
# check param constraints first here as this is quite optimized:
@@ -88,6 +97,7 @@ proc isPatternParam(c: PPatternContext, p: PNode): bool {.inline.} =
result = p.kind == nkSym and p.sym.kind == skParam and p.sym.owner == c.owner
proc matchChoice(c: PPatternContext, p, n: PNode): bool =
result = false
for i in 1..<p.len:
if matches(c, p[i], n): return true
@@ -99,6 +109,8 @@ proc bindOrCheck(c: PPatternContext, param: PSym, n: PNode): bool =
elif n.kind == nkArgList or checkTypes(c, param, n):
putLazy(c, param, n)
result = true
else:
result = false
proc gather(c: PPatternContext, param: PSym, n: PNode) =
var pp = getLazy(c, param)
@@ -132,6 +144,10 @@ proc matchNested(c: PPatternContext, p, n: PNode, rpn: bool): bool =
var arglist = newNodeI(nkArgList, n.info)
if matchStarAux(c, p, n, arglist, rpn):
result = bindOrCheck(c, p[2].sym, arglist)
else:
result = false
else:
result = false
proc matches(c: PPatternContext, p, n: PNode): bool =
let n = skipHidden(n)
@@ -147,6 +163,7 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
# try both:
if p.kind == nkSym: result = p.sym == n.sym
elif matches(c, p, n.sym.astdef): result = true
else: result = false
elif p.kind == nkPattern:
# pattern operators: | *
let opr = p[0].ident.s
@@ -155,7 +172,9 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
of "*": result = matchNested(c, p, n, rpn=false)
of "**": result = matchNested(c, p, n, rpn=true)
of "~": result = not matches(c, p[1], n)
else: doAssert(false, "invalid pattern")
else:
result = false
doAssert(false, "invalid pattern")
# template {add(a, `&` * b)}(a: string{noalias}, b: varargs[string]) =
# a.add(b)
elif p.kind == nkCurlyExpr:
@@ -163,10 +182,14 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
if matches(c, p[0], n):
gather(c, p[1][1].sym, n)
result = true
else:
result = false
else:
assert isPatternParam(c, p[1])
if matches(c, p[0], n):
result = bindOrCheck(c, p[1].sym, n)
else:
result = false
elif sameKinds(p, n):
case p.kind
of nkSym: result = p.sym == n.sym
@@ -179,6 +202,7 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
else:
# special rule for p(X) ~ f(...); this also works for stuff like
# partial case statements, etc! - Not really ... :-/
result = false
let v = lastSon(p)
if isPatternParam(c, v) and v.sym.typ.kind == tyVarargs:
var arglist: PNode
@@ -207,6 +231,8 @@ proc matches(c: PPatternContext, p, n: PNode): bool =
for i in 0..<p.len:
if not matches(c, p[i], n[i]): return
result = true
else:
result = false
proc matchStmtList(c: PPatternContext, p, n: PNode): PNode =
proc matchRange(c: PPatternContext, p, n: PNode, i: int): bool =
@@ -219,6 +245,7 @@ proc matchStmtList(c: PPatternContext, p, n: PNode): PNode =
result = true
if p.kind == nkStmtList and n.kind == p.kind and p.len < n.len:
result = nil
let n = flattenStmts(n)
# no need to flatten 'p' here as that has already been done
for i in 0..n.len - p.len:
@@ -231,8 +258,11 @@ proc matchStmtList(c: PPatternContext, p, n: PNode): PNode =
break
elif matches(c, p, n):
result = n
else:
result = nil
proc aliasAnalysisRequested(params: PNode): bool =
result = false
if params.len >= 2:
for i in 1..<params.len:
let param = params[i].sym
@@ -258,9 +288,11 @@ proc applyRule*(c: PContext, s: PSym, n: PNode): PNode =
result.add(newSymNode(s, n.info))
let params = s.typ.n
let requiresAA = aliasAnalysisRequested(params)
var args: PNode
if requiresAA:
args = newNodeI(nkArgList, n.info)
var args: PNode =
if requiresAA:
newNodeI(nkArgList, n.info)
else:
nil
for i in 1..<params.len:
let param = params[i].sym
let x = getLazy(ctx, param)

11
compiler/pipelines.nim
View File

@@ -25,6 +25,8 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
of JSgenPass:
when not defined(leanCompiler):
result = processJSCodeGen(bModule, semNode)
else:
result = nil
of GenDependPass:
result = addDotDependency(bModule, semNode)
of SemPass:
@@ -32,12 +34,17 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
of Docgen2Pass, Docgen2TexPass:
when not defined(leanCompiler):
result = processNode(bModule, semNode)
else:
result = nil
of Docgen2JsonPass:
when not defined(leanCompiler):
result = processNodeJson(bModule, semNode)
else:
result = nil
of EvalPass, InterpreterPass:
result = interpreterCode(bModule, semNode)
of NonePass:
result = nil
doAssert false, "use setPipeLinePass to set a proper PipelinePass"
proc processImplicitImports(graph: ModuleGraph; implicits: seq[string], nodeKind: TNodeKind,
@@ -217,13 +224,13 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
template processModuleAux(moduleStatus) =
onProcessing(graph, fileIdx, moduleStatus, fromModule = fromModule)
var s: PLLStream
var s: PLLStream = nil
if sfMainModule in flags:
if graph.config.projectIsStdin: s = stdin.llStreamOpen
elif graph.config.projectIsCmd: s = llStreamOpen(graph.config.cmdInput)
discard processPipelineModule(graph, result, idGeneratorFromModule(result), s)
if result == nil:
var cachedModules: seq[FileIndex]
var cachedModules: seq[FileIndex] = @[]
result = moduleFromRodFile(graph, fileIdx, cachedModules)
let filename = AbsoluteFile toFullPath(graph.config, fileIdx)
if result == nil:

2
compiler/platform.nim
View File

@@ -277,6 +277,7 @@ proc nameToOS*(name: string): TSystemOS =
result = osNone
proc listOSnames*(): seq[string] =
result = @[]
for i in succ(osNone)..high(TSystemOS):
result.add OS[i].name
@@ -287,6 +288,7 @@ proc nameToCPU*(name: string): TSystemCPU =
result = cpuNone
proc listCPUnames*(): seq[string] =
result = @[]
for i in succ(cpuNone)..high(TSystemCPU):
result.add CPU[i].name

4
compiler/pragmas.nim
View File

@@ -94,6 +94,7 @@ const
enumFieldPragmas* = {wDeprecated}
proc getPragmaVal*(procAst: PNode; name: TSpecialWord): PNode =
result = nil
let p = procAst[pragmasPos]
if p.kind == nkEmpty: return nil
for it in p:
@@ -231,6 +232,7 @@ proc expectStrLit(c: PContext, n: PNode): string =
result = getStrLitNode(c, n).strVal
proc expectIntLit(c: PContext, n: PNode): int =
result = 0
if n.kind notin nkPragmaCallKinds or n.len != 2:
localError(c.config, n.info, errIntLiteralExpected)
else:
@@ -276,6 +278,7 @@ proc wordToCallConv(sw: TSpecialWord): TCallingConvention =
TCallingConvention(ord(ccNimCall) + ord(sw) - ord(wNimcall))
proc isTurnedOn(c: PContext, n: PNode): bool =
result = false
if n.kind in nkPragmaCallKinds and n.len == 2:
let x = c.semConstBoolExpr(c, n[1])
n[1] = x
@@ -824,6 +827,7 @@ proc processEffectsOf(c: PContext, n: PNode; owner: PSym) =
proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
validPragmas: TSpecialWords,
comesFromPush, isStatement: bool): bool =
result = false
var it = n[i]
let keyDeep = it.kind in nkPragmaCallKinds and it.len > 1
var key = if keyDeep: it[0] else: it

46
compiler/renderer.nim
View File

@@ -76,6 +76,8 @@ proc isKeyword*(i: PIdent): bool =
if (i.id >= ord(tokKeywordLow) - ord(tkSymbol)) and
(i.id <= ord(tokKeywordHigh) - ord(tkSymbol)):
result = true
else:
result = false
proc isExported(n: PNode): bool =
## Checks if an ident is exported.
@@ -274,6 +276,7 @@ proc putComment(g: var TSrcGen, s: string) =
optNL(g)
proc maxLineLength(s: string): int =
result = 0
if s.len == 0: return 0
var i = 0
let hi = s.len - 1
@@ -371,6 +374,7 @@ proc litAux(g: TSrcGen; n: PNode, x: BiggestInt, size: int): string =
tyLent, tyDistinct, tyOrdinal, tyAlias, tySink}:
result = lastSon(result)
result = ""
let typ = n.typ.skip
if typ != nil and typ.kind in {tyBool, tyEnum}:
if sfPure in typ.sym.flags:
@@ -488,6 +492,7 @@ proc referencesUsing(n: PNode): bool =
proc lsub(g: TSrcGen; n: PNode): int =
# computes the length of a tree
result = 0
if isNil(n): return 0
if shouldRenderComment(g, n): return MaxLineLen + 1
case n.kind
@@ -631,7 +636,7 @@ proc initContext(c: var TContext) =
proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false)
proc gsub(g: var TSrcGen, n: PNode, fromStmtList = false) =
var c: TContext
var c: TContext = default(TContext)
initContext(c)
gsub(g, n, c, fromStmtList = fromStmtList)
@@ -762,7 +767,7 @@ proc gcond(g: var TSrcGen, n: PNode) =
put(g, tkParRi, ")")
proc gif(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
gcond(g, n[0][0])
initContext(c)
putWithSpace(g, tkColon, ":")
@@ -775,7 +780,7 @@ proc gif(g: var TSrcGen, n: PNode) =
gsub(g, n[i], c)
proc gwhile(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
putWithSpace(g, tkWhile, "while")
gcond(g, n[0])
putWithSpace(g, tkColon, ":")
@@ -786,7 +791,7 @@ proc gwhile(g: var TSrcGen, n: PNode) =
gstmts(g, n[1], c)
proc gpattern(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
put(g, tkCurlyLe, "{")
initContext(c)
if longMode(g, n) or (lsub(g, n[0]) + g.lineLen > MaxLineLen):
@@ -796,7 +801,7 @@ proc gpattern(g: var TSrcGen, n: PNode) =
put(g, tkCurlyRi, "}")
proc gpragmaBlock(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
gsub(g, n[0])
putWithSpace(g, tkColon, ":")
initContext(c)
@@ -806,7 +811,7 @@ proc gpragmaBlock(g: var TSrcGen, n: PNode) =
gstmts(g, n[1], c)
proc gtry(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
put(g, tkTry, "try")
putWithSpace(g, tkColon, ":")
initContext(c)
@@ -817,7 +822,7 @@ proc gtry(g: var TSrcGen, n: PNode) =
gsons(g, n, c, 1)
proc gfor(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
putWithSpace(g, tkFor, "for")
initContext(c)
if longMode(g, n) or
@@ -832,7 +837,7 @@ proc gfor(g: var TSrcGen, n: PNode) =
gstmts(g, n[^1], c)
proc gcase(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
initContext(c)
if n.len == 0: return
var last = if n[^1].kind == nkElse: -2 else: -1
@@ -853,7 +858,7 @@ proc genSymSuffix(result: var string, s: PSym) {.inline.} =
result.addInt s.id
proc gproc(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
if n[namePos].kind == nkSym:
let s = n[namePos].sym
var ret = renderDefinitionName(s)
@@ -889,7 +894,7 @@ proc gproc(g: var TSrcGen, n: PNode) =
dedent(g)
proc gTypeClassTy(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
initContext(c)
putWithSpace(g, tkConcept, "concept")
gsons(g, n[0], c) # arglist
@@ -909,7 +914,7 @@ proc gblock(g: var TSrcGen, n: PNode) =
if n.len == 0:
return
var c: TContext
var c: TContext = default(TContext)
initContext(c)
if n[0].kind != nkEmpty:
@@ -930,7 +935,7 @@ proc gblock(g: var TSrcGen, n: PNode) =
gstmts(g, n[1], c)
proc gstaticStmt(g: var TSrcGen, n: PNode) =
var c: TContext
var c: TContext = default(TContext)
putWithSpace(g, tkStatic, "static")
putWithSpace(g, tkColon, ":")
initContext(c)
@@ -1005,6 +1010,7 @@ proc bracketKind*(g: TSrcGen, n: PNode): BracketKind =
case n.kind
of nkClosedSymChoice, nkOpenSymChoice:
if n.len > 0: result = bracketKind(g, n[0])
else: result = bkNone
of nkSym:
result = case n.sym.name.s
of "[]": bkBracket
@@ -1013,6 +1019,8 @@ proc bracketKind*(g: TSrcGen, n: PNode): BracketKind =
of "{}=": bkCurlyAsgn
else: bkNone
else: result = bkNone
else:
result = bkNone
proc skipHiddenNodes(n: PNode): PNode =
result = n
@@ -1085,11 +1093,13 @@ proc isCustomLit(n: PNode): bool =
if n.len == 2 and n[0].kind == nkRStrLit:
let ident = n[1].getPIdent
result = ident != nil and ident.s.startsWith('\'')
else:
result = false
proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
if isNil(n): return
var
a: TContext
a: TContext = default(TContext)
if shouldRenderComment(g, n): pushCom(g, n)
case n.kind # atoms:
of nkTripleStrLit: put(g, tkTripleStrLit, atom(g, n))
@@ -1437,6 +1447,8 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
if n.kind in {nkIdent, nkSym}:
let tmp = n.getPIdent.s
result = tmp.len > 0 and tmp[0] in {'a'..'z', 'A'..'Z'}
else:
result = false
var useSpace = false
if i == 1 and n[0].kind == nkIdent and n[0].ident.s in ["=", "'"]:
if not n[1].isAlpha: # handle `=destroy`, `'big'
@@ -1787,12 +1799,12 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
gsub(g, n, 0)
put(g, tkParRi, ")")
of nkGotoState:
var c: TContext
var c: TContext = default(TContext)
initContext c
putWithSpace g, tkSymbol, "goto"
gsons(g, n, c)
of nkState:
var c: TContext
var c: TContext = default(TContext)
initContext c
putWithSpace g, tkSymbol, "state"
gsub(g, n[0], c)
@@ -1817,7 +1829,7 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
proc renderTree*(n: PNode, renderFlags: TRenderFlags = {}): string =
if n == nil: return "<nil tree>"
var g: TSrcGen
var g: TSrcGen = default(TSrcGen)
initSrcGen(g, renderFlags, newPartialConfigRef())
# do not indent the initial statement list so that
# writeFile("file.nim", repr n)
@@ -1835,7 +1847,7 @@ proc renderModule*(n: PNode, outfile: string,
fid = FileIndex(-1);
conf: ConfigRef = nil) =
var
f: File
f: File = default(File)
g: TSrcGen
initSrcGen(g, renderFlags, conf)
g.fid = fid

1
compiler/renderverbatim.nim
View File

@@ -40,6 +40,7 @@ type LineData = object
proc tripleStrLitStartsAtNextLine(conf: ConfigRef, n: PNode): bool =
# enabling TLineInfo.offsetA,offsetB would probably make this easier
result = false
const tripleQuote = "\"\"\""
let src = sourceLine(conf, n.info)
let col = n.info.col

7
compiler/reorder.nim
View File

@@ -115,6 +115,7 @@ proc computeDeps(cache: IdentCache; n: PNode, declares, uses: var IntSet; topLev
for i in 0..<n.safeLen: deps(n[i])
proc hasIncludes(n:PNode): bool =
result = false
for a in n:
if a.kind == nkIncludeStmt:
return true
@@ -268,6 +269,7 @@ proc hasCommand(n: DepN): bool =
result = bool(n.hCmd)
proc hasAccQuoted(n: PNode): bool =
result = false
if n.kind == nkAccQuoted:
return true
for a in n:
@@ -283,6 +285,7 @@ proc hasAccQuotedDef(n: PNode): bool =
of extendedProcDefs:
result = n[0].hasAccQuoted
of nkStmtList, nkStmtListExpr, nkWhenStmt, nkElifBranch, nkElse, nkStaticStmt:
result = false
for a in n:
if hasAccQuotedDef(a):
return true
@@ -303,6 +306,7 @@ proc hasBody(n: PNode): bool =
of extendedProcDefs:
result = n[^1].kind == nkStmtList
of nkStmtList, nkStmtListExpr, nkWhenStmt, nkElifBranch, nkElse, nkStaticStmt:
result = false
for a in n:
if a.hasBody:
return true
@@ -315,6 +319,7 @@ proc hasBody(n: DepN): bool =
result = bool(n.hB)
proc intersects(s1, s2: IntSet): bool =
result = false
for a in s1:
if s2.contains(a):
return true
@@ -393,6 +398,7 @@ proc strongConnect(v: var DepN, idx: var int, s: var seq[DepN],
proc getStrongComponents(g: var DepG): seq[seq[DepN]] =
## Tarjan's algorithm. Performs a topological sort
## and detects strongly connected components.
result = @[]
var s: seq[DepN]
var idx = 0
for v in g.mitems:
@@ -402,6 +408,7 @@ proc getStrongComponents(g: var DepG): seq[seq[DepN]] =
proc hasForbiddenPragma(n: PNode): bool =
# Checks if the tree node has some pragmas that do not
# play well with reordering, like the push/pop pragma
result = false
for a in n:
if a.kind == nkPragma and a[0].kind == nkIdent and
a[0].ident.s == "push":

1
compiler/rodutils.nim
View File

@@ -61,6 +61,7 @@ proc toStrMaxPrecision*(f: BiggestFloat | float32): string =
of fcNegInf:
result = "-INF"
else:
result = ""
result.addFloatRoundtrip(f)
result.add literalPostfix

6
compiler/ropes.nim
View File

@@ -43,7 +43,7 @@ proc writeRope*(f: File, r: Rope) =
write(f, r)
proc writeRope*(head: Rope, filename: AbsoluteFile): bool =
var f: File
var f: File = default(File)
if open(f, filename.string, fmWrite):
writeRope(f, head)
close(f)
@@ -119,7 +119,7 @@ const
proc equalsFile*(s: Rope, f: File): bool =
## returns true if the contents of the file `f` equal `r`.
var
buf: array[bufSize, char]
buf: array[bufSize, char] = default(array[bufSize, char])
bpos = buf.len
blen = buf.len
btotal = 0
@@ -151,7 +151,7 @@ proc equalsFile*(s: Rope, f: File): bool =
proc equalsFile*(r: Rope, filename: AbsoluteFile): bool =
## returns true if the contents of the file `f` equal `r`. If `f` does not
## exist, false is returned.
var f: File
var f: File = default(File)
result = open(f, filename.string)
if result:
result = equalsFile(r, f)

22
compiler/sem.nim
View File

@@ -96,6 +96,7 @@ proc fitNode(c: PContext, formal: PType, arg: PNode; info: TLineInfo): PNode =
result.typ = formal
elif arg.kind in nkSymChoices and formal.skipTypes(abstractInst).kind == tyEnum:
# Pick the right 'sym' from the sym choice by looking at 'formal' type:
result = nil
for ch in arg:
if sameType(ch.typ, formal):
return getConstExpr(c.module, ch, c.idgen, c.graph)
@@ -149,7 +150,7 @@ proc commonType*(c: PContext; x, y: PType): PType =
let idx = ord(b.kind == tyArray)
if a[idx].kind == tyEmpty: return y
elif a.kind == tyTuple and b.kind == tyTuple and a.len == b.len:
var nt: PType
var nt: PType = nil
for i in 0..<a.len:
let aEmpty = isEmptyContainer(a[i])
let bEmpty = isEmptyContainer(b[i])
@@ -305,6 +306,7 @@ when false:
result = isOpImpl(c, n)
proc hasCycle(n: PNode): bool =
result = false
incl n.flags, nfNone
for i in 0..<n.safeLen:
if nfNone in n[i].flags or hasCycle(n[i]):
@@ -539,6 +541,7 @@ proc setGenericParamsMisc(c: PContext; n: PNode) =
n[miscPos][1] = orig
proc caseBranchMatchesExpr(branch, matched: PNode): bool =
result = false
for i in 0 ..< branch.len-1:
if branch[i].kind == nkRange:
if overlap(branch[i], matched): return true
@@ -546,6 +549,7 @@ proc caseBranchMatchesExpr(branch, matched: PNode): bool =
return true
proc pickCaseBranchIndex(caseExpr, matched: PNode): int =
result = 0
let endsWithElse = caseExpr[^1].kind == nkElse
for i in 1..<caseExpr.len - endsWithElse.int:
if caseExpr[i].caseBranchMatchesExpr(matched):
@@ -560,6 +564,7 @@ proc defaultNodeField(c: PContext, a: PNode, checkDefault: bool): PNode
const defaultFieldsSkipTypes = {tyGenericInst, tyAlias, tySink}
proc defaultFieldsForTuple(c: PContext, recNode: PNode, hasDefault: var bool, checkDefault: bool): seq[PNode] =
result = @[]
case recNode.kind
of nkRecList:
for field in recNode:
@@ -592,6 +597,7 @@ proc defaultFieldsForTuple(c: PContext, recNode: PNode, hasDefault: var bool, ch
doAssert false
proc defaultFieldsForTheUninitialized(c: PContext, recNode: PNode, checkDefault: bool): seq[PNode] =
result = @[]
case recNode.kind
of nkRecList:
for field in recNode:
@@ -635,6 +641,8 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
asgnExpr.typ = aTyp
asgnExpr.sons.add child
result = semExpr(c, asgnExpr)
else:
result = nil
elif aTypSkip.kind == tyArray:
let child = defaultNodeField(c, a, aTypSkip[1], checkDefault)
@@ -646,6 +654,8 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
node
))
result.typ = aTyp
else:
result = nil
elif aTypSkip.kind == tyTuple:
var hasDefault = false
if aTypSkip.n != nil:
@@ -655,6 +665,12 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
result.typ = aTyp
result.sons.add children
result = semExpr(c, result)
else:
result = nil
else:
result = nil
else:
result = nil
proc defaultNodeField(c: PContext, a: PNode, checkDefault: bool): PNode =
result = defaultNodeField(c, a, a.typ, checkDefault)
@@ -714,17 +730,19 @@ proc isImportSystemStmt(g: ModuleGraph; n: PNode): bool =
break
case n.kind
of nkImportStmt:
result = false
for x in n:
if x.kind == nkIdent:
let f = checkModuleName(g.config, x, false)
if f == g.systemModule.info.fileIndex:
return true
of nkImportExceptStmt, nkFromStmt:
result = false
if n[0].kind == nkIdent:
let f = checkModuleName(g.config, n[0], false)
if f == g.systemModule.info.fileIndex:
return true
else: discard
else: result = false
proc isEmptyTree(n: PNode): bool =
case n.kind

16
compiler/semcall.nim
View File

@@ -82,7 +82,7 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
# starts at 1 because 0 is already done with setup, only needs checking
var nextSymIndex = 1
var z: TCandidate # current candidate
var z: TCandidate = default(TCandidate) # current candidate
while true:
determineType(c, sym)
initCandidate(c, z, sym, initialBinding, scope, diagnosticsFlag)
@@ -215,7 +215,7 @@ proc presentFailedCandidates(c: PContext, n: PNode, errors: CandidateErrors):
var maybeWrongSpace = false
var candidatesAll: seq[string]
var candidatesAll: seq[string] = @[]
var candidates = ""
var skipped = 0
for err in errors:
@@ -370,6 +370,7 @@ proc bracketNotFoundError(c: PContext; n: PNode) =
notFoundError(c, n, errors)
proc getMsgDiagnostic(c: PContext, flags: TExprFlags, n, f: PNode): string =
result = ""
if c.compilesContextId > 0:
# we avoid running more diagnostic when inside a `compiles(expr)`, to
# errors while running diagnostic (see test D20180828T234921), and
@@ -405,8 +406,9 @@ proc resolveOverloads(c: PContext, n, orig: PNode,
filter: TSymKinds, flags: TExprFlags,
errors: var CandidateErrors,
errorsEnabled: bool): TCandidate =
result = default(TCandidate)
var initialBinding: PNode
var alt: TCandidate
var alt: TCandidate = default(TCandidate)
var f = n[0]
if f.kind == nkBracketExpr:
# fill in the bindings:
@@ -569,8 +571,8 @@ proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
if expectedType == nil or x.callee[0] == nil: return # required for inference
var
flatUnbound: seq[PType]
flatBound: seq[PType]
flatUnbound: seq[PType] = @[]
flatBound: seq[PType] = @[]
# seq[(result type, expected type)]
var typeStack = newSeq[(PType, PType)]()
@@ -694,7 +696,10 @@ proc semOverloadedCall(c: PContext, n, nOrig: PNode,
# this time enabling all the diagnostic output (this should fail again)
result = semOverloadedCall(c, n, nOrig, filter, flags + {efExplain})
elif efNoUndeclared notin flags:
result = nil
notFoundError(c, n, errors)
else:
result = nil
proc explicitGenericInstError(c: PContext; n: PNode): PNode =
localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
@@ -771,6 +776,7 @@ proc searchForBorrowProc(c: PContext, startScope: PScope, fn: PSym): PSym =
# for borrowing the sym in the symbol table is returned, else nil.
# New approach: generate fn(x, y, z) where x, y, z have the proper types
# and use the overloading resolution mechanism:
result = nil
var call = newNodeI(nkCall, fn.info)
var hasDistinct = false
call.add(newIdentNode(fn.name, fn.info))

21
compiler/semexprs.nim
View File

@@ -655,7 +655,7 @@ proc semArrayConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
else: discard
rawAddSon(result.typ, nil) # index type
var
firstIndex, lastIndex: Int128
firstIndex, lastIndex: Int128 = Zero
indexType = getSysType(c.graph, n.info, tyInt)
lastValidIndex = lastOrd(c.config, indexType)
if n.len == 0:
@@ -990,6 +990,7 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
proc resolveIndirectCall(c: PContext; n, nOrig: PNode;
t: PType): TCandidate =
result = default(TCandidate)
initCandidate(c, result, t)
matches(c, n, nOrig, result)
@@ -998,6 +999,8 @@ proc bracketedMacro(n: PNode): PSym =
result = n[0].sym
if result.kind notin {skMacro, skTemplate}:
result = nil
else:
result = nil
proc setGenericParams(c: PContext, n: PNode) =
for i in 1..<n.len:
@@ -1282,6 +1285,7 @@ proc readTypeParameter(c: PContext, typ: PType,
return nil
proc semSym(c: PContext, n: PNode, sym: PSym, flags: TExprFlags): PNode =
result = nil
assert n.kind in nkIdentKinds + {nkDotExpr}
let s = getGenSym(c, sym)
case s.kind
@@ -1406,9 +1410,10 @@ proc tryReadingGenericParam(c: PContext, n: PNode, i: PIdent, t: PType): PNode =
n.typ = makeTypeFromExpr(c, copyTree(n))
result = n
else:
discard
result = nil
proc tryReadingTypeField(c: PContext, n: PNode, i: PIdent, ty: PType): PNode =
result = nil
var ty = ty.skipTypes(tyDotOpTransparent)
case ty.kind
of tyEnum:
@@ -1606,6 +1611,7 @@ proc maybeInstantiateGeneric(c: PContext, n: PNode, s: PSym): PNode =
proc semSubscript(c: PContext, n: PNode, flags: TExprFlags): PNode =
## returns nil if not a built-in subscript operator; also called for the
## checking of assignments
result = nil
if n.len == 1:
let x = semDeref(c, n)
if x == nil: return nil
@@ -2306,7 +2312,7 @@ proc tryExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
if c.config.errorCounter != oldErrorCount:
result = nil
except ERecoverableError:
discard
result = nil
# undo symbol table changes (as far as it's possible):
c.compilesContextId = oldCompilesId
c.generics = oldGenerics
@@ -2355,7 +2361,7 @@ proc instantiateCreateFlowVarCall(c: PContext; t: PType;
let sym = magicsys.getCompilerProc(c.graph, "nimCreateFlowVar")
if sym == nil:
localError(c.config, info, "system needs: nimCreateFlowVar")
var bindings: TIdTable
var bindings: TIdTable = default(TIdTable)
initIdTable(bindings)
bindings.idTablePut(sym.ast[genericParamsPos][0].typ, t)
result = c.semGenerateInstance(c, sym, bindings, info)
@@ -2822,7 +2828,7 @@ proc semExport(c: PContext, n: PNode): PNode =
proc semTupleConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
var tupexp = semTuplePositionsConstr(c, n, flags, expectedType)
var isTupleType: bool
var isTupleType: bool = false
if tupexp.len > 0: # don't interpret () as type
isTupleType = tupexp[0].typ.kind == tyTypeDesc
# check if either everything or nothing is tyTypeDesc
@@ -2837,6 +2843,7 @@ proc semTupleConstr(c: PContext, n: PNode, flags: TExprFlags; expectedType: PTyp
result = tupexp
proc shouldBeBracketExpr(n: PNode): bool =
result = false
assert n.kind in nkCallKinds
let a = n[0]
if a.kind in nkCallKinds:
@@ -2854,6 +2861,8 @@ proc asBracketExpr(c: PContext; n: PNode): PNode =
if n.kind in {nkIdent, nkAccQuoted}:
let s = qualifiedLookUp(c, n, {})
result = s != nil and isGenericRoutineStrict(s)
else:
result = false
assert n.kind in nkCallKinds
if n.len > 1 and isGeneric(c, n[1]):
@@ -2983,7 +2992,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
if nfSem in n.flags: return
case n.kind
of nkIdent, nkAccQuoted:
var s: PSym
var s: PSym = nil
if expectedType != nil and (
let expected = expectedType.skipTypes(abstractRange-{tyDistinct});
expected.kind == tyEnum):

28
compiler/semfold.nim
View File

@@ -65,24 +65,34 @@ proc foldAdd(a, b: Int128, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
let res = a + b
if checkInRange(g.config, n, res):
result = newIntNodeT(res, n, idgen, g)
else:
result = nil
proc foldSub(a, b: Int128, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
let res = a - b
if checkInRange(g.config, n, res):
result = newIntNodeT(res, n, idgen, g)
else:
result = nil
proc foldUnarySub(a: Int128, n: PNode; idgen: IdGenerator, g: ModuleGraph): PNode =
if a != firstOrd(g.config, n.typ):
result = newIntNodeT(-a, n, idgen, g)
else:
result = nil
proc foldAbs(a: Int128, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
if a != firstOrd(g.config, n.typ):
result = newIntNodeT(abs(a), n, idgen, g)
else:
result = nil
proc foldMul(a, b: Int128, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
let res = a * b
if checkInRange(g.config, n, res):
return newIntNodeT(res, n, idgen, g)
else:
result = nil
proc ordinalValToString*(a: PNode; g: ModuleGraph): string =
# because $ has the param ordinal[T], `a` is not necessarily an enum, but an
@@ -94,6 +104,7 @@ proc ordinalValToString*(a: PNode; g: ModuleGraph): string =
of tyChar:
result = $chr(toInt64(x) and 0xff)
of tyEnum:
result = ""
var n = t.n
for i in 0..<n.len:
if n[i].kind != nkSym: internalError(g.config, a.info, "ordinalValToString")
@@ -346,7 +357,7 @@ proc magicCall(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
var s = n[0].sym
var a = getConstExpr(m, n[1], idgen, g)
var b, c: PNode
var b, c: PNode = nil
if a == nil: return
if n.len > 2:
b = getConstExpr(m, n[2], idgen, g)
@@ -396,7 +407,9 @@ proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): P
of tyBool, tyEnum: # xxx shouldn't we disallow `tyEnum`?
result = a
result.typ = n.typ
else: doAssert false, $srcTyp.kind
else:
result = nil
doAssert false, $srcTyp.kind
of tyInt..tyInt64, tyUInt..tyUInt64:
case srcTyp.kind
of tyFloat..tyFloat64:
@@ -420,7 +433,7 @@ proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): P
result = a
result.typ = n.typ
of tyOpenArray, tyVarargs, tyProc, tyPointer:
discard
result = nil
else:
result = a
result.typ = n.typ
@@ -447,21 +460,25 @@ proc foldArrayAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNo
result = x.sons[idx]
if result.kind == nkExprColonExpr: result = result[1]
else:
result = nil
localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
of nkBracket:
idx -= toInt64(firstOrd(g.config, x.typ))
if idx >= 0 and idx < x.len: result = x[int(idx)]
else: localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
else:
result = nil
localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
of nkStrLit..nkTripleStrLit:
result = newNodeIT(nkCharLit, x.info, n.typ)
if idx >= 0 and idx < x.strVal.len:
result.intVal = ord(x.strVal[int(idx)])
else:
localError(g.config, n.info, formatErrorIndexBound(idx, x.strVal.len-1) & $n)
else: discard
else: result = nil
proc foldFieldAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
# a real field access; proc calls have already been transformed
result = nil
if n[1].kind != nkSym: return nil
var x = getConstExpr(m, n[0], idgen, g)
if x == nil or x.kind notin {nkObjConstr, nkPar, nkTupleConstr}: return
@@ -496,6 +513,7 @@ proc newSymNodeTypeDesc*(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode =
result.typ = s.typ
proc foldDefine(m, s: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
result = nil
var name = s.name.s
let prag = extractPragma(s)
if prag != nil:

3
compiler/semgnrc.nim
View File

@@ -59,6 +59,7 @@ template isMixedIn(sym): bool =
proc semGenericStmtSymbol(c: PContext, n: PNode, s: PSym,
ctx: var GenericCtx; flags: TSemGenericFlags,
fromDotExpr=false): PNode =
result = nil
semIdeForTemplateOrGenericCheck(c.config, n, ctx.cursorInBody)
incl(s.flags, sfUsed)
template maybeDotChoice(c: PContext, n: PNode, s: PSym, fromDotExpr: bool) =
@@ -439,7 +440,7 @@ proc semGenericStmt(c: PContext, n: PNode,
if n[0].kind != nkEmpty:
n[0] = semGenericStmt(c, n[0], flags+{withinTypeDesc}, ctx)
for i in 1..<n.len:
var a: PNode
var a: PNode = nil
case n[i].kind
of nkEnumFieldDef: a = n[i][0]
of nkIdent: a = n[i]

5
compiler/seminst.nim
View File

@@ -76,9 +76,12 @@ proc sameInstantiation(a, b: TInstantiation): bool =
ExactGcSafety,
PickyCAliases}): return
result = true
else:
result = false
proc genericCacheGet(g: ModuleGraph; genericSym: PSym, entry: TInstantiation;
id: CompilesId): PSym =
result = nil
for inst in procInstCacheItems(g, genericSym):
if (inst.compilesId == 0 or inst.compilesId == id) and sameInstantiation(entry, inst[]):
return inst.sym
@@ -171,7 +174,7 @@ proc instGenericContainer(c: PContext, info: TLineInfo, header: PType,
internalAssert c.config, header.kind == tyGenericInvocation
var
cl: TReplTypeVars
cl: TReplTypeVars = default(TReplTypeVars)
initIdTable(cl.symMap)
initIdTable(cl.localCache)

5
compiler/semmagic.nim
View File

@@ -92,7 +92,9 @@ proc expectIntLit(c: PContext, n: PNode): int =
let x = c.semConstExpr(c, n)
case x.kind
of nkIntLit..nkInt64Lit: result = int(x.intVal)
else: localError(c.config, n.info, errIntLiteralExpected)
else:
result = 0
localError(c.config, n.info, errIntLiteralExpected)
proc semInstantiationInfo(c: PContext, n: PNode): PNode =
result = newNodeIT(nkTupleConstr, n.info, n.typ)
@@ -287,6 +289,7 @@ proc opBindSym(c: PContext, scope: PScope, n: PNode, isMixin: int, info: PNode):
# we need to mark all symbols:
result = symChoice(c, id, s, TSymChoiceRule(isMixin))
else:
result = nil
errorUndeclaredIdentifier(c, info.info, if n.kind == nkIdent: n.ident.s
else: n.strVal)
c.currentScope = tmpScope

27
compiler/semobjconstr.nim
View File

@@ -62,6 +62,7 @@ proc invalidObjConstr(c: PContext, n: PNode) =
proc locateFieldInInitExpr(c: PContext, field: PSym, initExpr: PNode): PNode =
# Returns the assignment nkExprColonExpr node or nil
result = nil
let fieldId = field.name.id
for i in 1..<initExpr.len:
let assignment = initExpr[i]
@@ -74,6 +75,7 @@ proc locateFieldInInitExpr(c: PContext, field: PSym, initExpr: PNode): PNode =
proc semConstrField(c: PContext, flags: TExprFlags,
field: PSym, initExpr: PNode): PNode =
result = nil
let assignment = locateFieldInInitExpr(c, field, initExpr)
if assignment != nil:
if nfSem in assignment.flags: return assignment[1]
@@ -106,6 +108,7 @@ proc branchVals(c: PContext, caseNode: PNode, caseIdx: int,
result.excl(val)
proc findUsefulCaseContext(c: PContext, discrimator: PNode): (PNode, int) =
result = (nil, 0)
for i in countdown(c.p.caseContext.high, 0):
let
(caseNode, index) = c.p.caseContext[i]
@@ -122,6 +125,8 @@ proc pickCaseBranch(caseExpr, matched: PNode): PNode =
if endsWithElse:
return caseExpr[^1]
else:
result = nil
iterator directFieldsInRecList(recList: PNode): PNode =
# XXX: We can remove this case by making all nkOfBranch nodes
@@ -153,21 +158,24 @@ proc locateFieldInDefaults(sym: PSym, defaults: seq[PNode]): bool =
proc collectMissingFields(c: PContext, fieldsRecList: PNode,
constrCtx: var ObjConstrContext, defaults: seq[PNode]
): seq[PSym] =
for r in directFieldsInRecList(fieldsRecList):
let assignment = locateFieldInInitExpr(c, r.sym, constrCtx.initExpr)
if assignment == nil and not locateFieldInDefaults(r.sym, defaults):
if constrCtx.needsFullInit or
sfRequiresInit in r.sym.flags or
r.sym.typ.requiresInit:
constrCtx.missingFields.add r.sym
else:
result.add r.sym
result = @[]
for r in directFieldsInRecList(fieldsRecList):
let assignment = locateFieldInInitExpr(c, r.sym, constrCtx.initExpr)
if assignment == nil and not locateFieldInDefaults(r.sym, defaults):
if constrCtx.needsFullInit or
sfRequiresInit in r.sym.flags or
r.sym.typ.requiresInit:
constrCtx.missingFields.add r.sym
else:
result.add r.sym
proc collectMissingCaseFields(c: PContext, branchNode: PNode,
constrCtx: var ObjConstrContext, defaults: seq[PNode]): seq[PSym] =
if branchNode != nil:
let fieldsRecList = branchNode[^1]
result = collectMissingFields(c, fieldsRecList, constrCtx, defaults)
else:
result = @[]
proc collectOrAddMissingCaseFields(c: PContext, branchNode: PNode,
constrCtx: var ObjConstrContext, defaults: var seq[PNode]) =
@@ -186,6 +194,7 @@ proc collectOrAddMissingCaseFields(c: PContext, branchNode: PNode,
proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
result = (initUnknown, @[])
case n.kind
of nkRecList:
for field in n:

3
compiler/semparallel.nim
View File

@@ -184,7 +184,10 @@ proc stride(c: AnalysisCtx; n: PNode): BiggestInt =
let s = c.lookupSlot(n.sym)
if s >= 0 and c.locals[s].stride != nil:
result = c.locals[s].stride.intVal
else:
result = 0
else:
result = 0
for i in 0..<n.safeLen: result += stride(c, n[i])
proc subStride(c: AnalysisCtx; n: PNode): PNode =

4
compiler/sempass2.nim
View File

@@ -529,6 +529,8 @@ proc isIndirectCall(tracked: PEffects; n: PNode): bool =
result = tracked.owner != n.sym.owner or tracked.owner == nil
elif n.sym.kind notin routineKinds:
result = true
else:
result = false
proc isForwardedProc(n: PNode): bool =
result = n.kind == nkSym and sfForward in n.sym.flags
@@ -1466,7 +1468,7 @@ proc trackProc*(c: PContext; s: PSym, body: PNode) =
var inferredEffects = newNodeI(nkEffectList, s.info)
var t: TEffects
var t: TEffects = default(TEffects)
initEffects(g, inferredEffects, s, t, c)
rawInitEffects g, effects

31
compiler/semstmts.nim
View File

@@ -44,8 +44,11 @@ proc hasEmpty(typ: PType): bool =
if typ.kind in {tySequence, tyArray, tySet}:
result = typ.lastSon.kind == tyEmpty
elif typ.kind == tyTuple:
result = false
for s in typ.sons:
result = result or hasEmpty(s)
else:
result = false
proc semDiscard(c: PContext, n: PNode): PNode =
result = n
@@ -67,7 +70,7 @@ proc semBreakOrContinue(c: PContext, n: PNode): PNode =
checkSonsLen(n, 1, c.config)
if n[0].kind != nkEmpty:
if n.kind != nkContinueStmt:
var s: PSym
var s: PSym = nil
case n[0].kind
of nkIdent: s = lookUp(c, n[0])
of nkSym: s = n[0].sym
@@ -273,7 +276,7 @@ proc semTry(c: PContext, n: PNode; flags: TExprFlags; expectedType: PType = nil)
# if ``except: body`` already encountered,
# cannot be followed by a ``except KeyError, ... : body`` block
inc catchAllExcepts
var isNative, isImported: bool
var isNative, isImported: bool = false
for j in 0..<a.len-1:
let tmp = semExceptBranchType(a[j])
if tmp: isImported = true
@@ -338,6 +341,7 @@ proc fitRemoveHiddenConv(c: PContext, typ: PType, n: PNode): PNode =
changeType(c, result, typ, check=false)
proc findShadowedVar(c: PContext, v: PSym): PSym =
result = nil
for scope in localScopesFrom(c, c.currentScope.parent):
let shadowed = strTableGet(scope.symbols, v.name)
if shadowed != nil and shadowed.kind in skLocalVars:
@@ -401,6 +405,8 @@ proc isDiscardUnderscore(v: PSym): bool =
if v.name.id == ord(wUnderscore):
v.flags.incl(sfGenSym)
result = true
else:
result = false
proc semUsing(c: PContext; n: PNode): PNode =
result = c.graph.emptyNode
@@ -579,6 +585,7 @@ template isLocalVarSym(n: PNode): bool =
n.kind == nkSym and isLocalSym(n.sym)
proc usesLocalVar(n: PNode): bool =
result = false
for z in 1 ..< n.len:
if n[z].isLocalVarSym:
return true
@@ -597,7 +604,7 @@ proc makeVarTupleSection(c: PContext, n, a, def: PNode, typ: PType, symkind: TSy
elif a.len-2 != typ.len:
localError(c.config, a.info, errWrongNumberOfVariables)
var
tmpTuple: PSym
tmpTuple: PSym = nil
lastDef: PNode
let defkind = if symkind == skConst: nkConstDef else: nkIdentDefs
# temporary not needed if not const and RHS is tuple literal
@@ -660,7 +667,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
if a[^2].kind != nkEmpty:
typ = semTypeNode(c, a[^2], nil)
var typFlags: TTypeAllowedFlags
var typFlags: TTypeAllowedFlags = {}
var def: PNode = c.graph.emptyNode
if a[^1].kind != nkEmpty:
@@ -807,7 +814,7 @@ proc semConst(c: PContext, n: PNode): PNode =
if a[^2].kind != nkEmpty:
typ = semTypeNode(c, a[^2], nil)
var typFlags: TTypeAllowedFlags
var typFlags: TTypeAllowedFlags = {}
# don't evaluate here since the type compatibility check below may add a converter
var def = semExprWithType(c, a[^1], {efTypeAllowed}, typ)
@@ -1029,6 +1036,8 @@ proc handleStmtMacro(c: PContext; n, selector: PNode; magicType: string;
of skMacro: result = semMacroExpr(c, callExpr, callExpr, match, flags)
of skTemplate: result = semTemplateExpr(c, callExpr, match, flags)
else: result = nil
else:
result = nil
proc handleForLoopMacro(c: PContext; n: PNode; flags: TExprFlags): PNode =
result = handleStmtMacro(c, n, n[^2], "ForLoopStmt", flags)
@@ -1058,6 +1067,8 @@ proc handleCaseStmtMacro(c: PContext; n: PNode; flags: TExprFlags): PNode =
else: result = errorNode(c, n[0])
elif r.state == csNoMatch:
result = errorNode(c, n[0])
else:
result = errorNode(c, n[0])
if result.kind == nkEmpty:
localError(c.config, n[0].info, errSelectorMustBeOfCertainTypes)
# this would be the perfectly consistent solution with 'for loop macros',
@@ -1231,7 +1242,7 @@ proc typeDefLeftSidePass(c: PContext, typeSection: PNode, i: int) =
let typeDef = typeSection[i]
checkSonsLen(typeDef, 3, c.config)
var name = typeDef[0]
var s: PSym
var s: PSym = nil
if name.kind == nkDotExpr and typeDef[2].kind == nkObjectTy:
let pkgName = considerQuotedIdent(c, name[0])
let typName = considerQuotedIdent(c, name[1])
@@ -1705,6 +1716,7 @@ proc addResult(c: PContext, n: PNode, t: PType, owner: TSymKind) =
proc semProcAnnotation(c: PContext, prc: PNode;
validPragmas: TSpecialWords): PNode =
# Mirrored with semVarMacroPragma
result = nil
var n = prc[pragmasPos]
if n == nil or n.kind == nkEmpty: return
for i in 0..<n.len:
@@ -2018,6 +2030,7 @@ proc semOverride(c: PContext, s: PSym, n: PNode) =
"'destroy' or 'deepCopy' expected for 'override'")
proc cursorInProcAux(conf: ConfigRef; n: PNode): bool =
result = false
if inCheckpoint(n.info, conf.m.trackPos) != cpNone: return true
for i in 0..<n.safeLen:
if cursorInProcAux(conf, n[i]): return true
@@ -2025,8 +2038,11 @@ proc cursorInProcAux(conf: ConfigRef; n: PNode): bool =
proc cursorInProc(conf: ConfigRef; n: PNode): bool =
if n.info.fileIndex == conf.m.trackPos.fileIndex:
result = cursorInProcAux(conf, n)
else:
result = false
proc hasObjParam(s: PSym): bool =
result = false
var t = s.typ
for col in 1..<t.len:
if skipTypes(t[col], skipPtrs).kind == tyObject:
@@ -2553,8 +2569,11 @@ proc usesResult(n: PNode): bool =
elif n.kind == nkReturnStmt:
result = true
else:
result = false
for c in n:
if usesResult(c): return true
else:
result = false
proc inferConceptStaticParam(c: PContext, inferred, n: PNode) =
var typ = inferred.typ

1
compiler/semtempl.nim
View File

@@ -34,6 +34,7 @@ type
spNone, spGenSym, spInject
proc symBinding(n: PNode): TSymBinding =
result = spNone
for i in 0..<n.len:
var it = n[i]
var key = if it.kind == nkExprColonExpr: it[0] else: it

39
compiler/semtypes.nim
View File

@@ -57,10 +57,10 @@ proc semEnum(c: PContext, n: PNode, prev: PType): PType =
# don't create an empty tyEnum; fixes #3052
return errorType(c)
var
counter, x: BiggestInt
e: PSym
base: PType
identToReplace: ptr PNode
counter, x: BiggestInt = 0
e: PSym = nil
base: PType = nil
identToReplace: ptr PNode = nil
counter = 0
base = nil
result = newOrPrevType(tyEnum, prev, c)
@@ -276,7 +276,7 @@ proc semRangeAux(c: PContext, n: PNode, prev: PType): PType =
range[0] = semExprWithType(c, n[1], {efDetermineType})
range[1] = semExprWithType(c, n[2], {efDetermineType})
var rangeT: array[2, PType]
var rangeT: array[2, PType] = default(array[2, PType])
for i in 0..1:
rangeT[i] = range[i].typ.skipTypes({tyStatic}).skipIntLit(c.idgen)
@@ -494,6 +494,7 @@ proc semIdentVis(c: PContext, kind: TSymKind, n: PNode,
else:
localError(c.config, n[0].info, errInvalidVisibilityX % renderTree(n[0]))
else:
result = nil
illFormedAst(n, c.config)
else:
result = newSymG(kind, n, c)
@@ -881,6 +882,7 @@ proc tryAddInheritedFields(c: PContext, check: var IntSet, pos: var int,
result = true
proc semObjectNode(c: PContext, n: PNode, prev: PType; flags: TTypeFlags): PType =
result = nil
if n.len == 0:
return newConstraint(c, tyObject)
var check = initIntSet()
@@ -1000,6 +1002,7 @@ proc findEnforcedStaticType(t: PType): PType =
# This handles types such as `static[T] and Foo`,
# which are subset of `static[T]`, hence they could
# be treated in the same way
result = nil
if t == nil: return nil
if t.kind == tyStatic: return t
if t.kind == tyAnd:
@@ -1099,13 +1102,16 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
let t = c.newTypeWithSons(tyTypeDesc, @[paramType.base])
incl t.flags, tfCheckedForDestructor
result = addImplicitGeneric(c, t, paramTypId, info, genericParams, paramName)
else:
result = nil
of tyDistinct:
if paramType.len == 1:
# disable the bindOnce behavior for the type class
result = recurse(paramType.base, true)
else:
result = nil
of tyTuple:
result = nil
for i in 0..<paramType.len:
let t = recurse(paramType[i])
if t != nil:
@@ -1128,6 +1134,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
@[newTypeS(paramType.kind, c)])
result = addImplicitGeneric(c, typ, paramTypId, info, genericParams, paramName)
else:
result = nil
for i in 0..<paramType.len:
if paramType[i] == paramType:
globalError(c.config, info, errIllegalRecursionInTypeX % typeToString(paramType))
@@ -1161,6 +1168,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
result = addImplicitGeneric(c, result, paramTypId, info, genericParams, paramName)
of tyGenericInst:
result = nil
if paramType.lastSon.kind == tyUserTypeClass:
var cp = copyType(paramType, nextTypeId c.idgen, getCurrOwner(c))
copyTypeProps(c.graph, c.idgen.module, cp, paramType)
@@ -1182,6 +1190,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
#result.shouldHaveMeta
of tyGenericInvocation:
result = nil
for i in 1..<paramType.len:
#if paramType[i].kind != tyTypeDesc:
let lifted = recurse(paramType[i])
@@ -1205,13 +1214,14 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
info, genericParams, paramName)
of tyGenericParam:
result = nil
markUsed(c, paramType.sym.info, paramType.sym)
onUse(paramType.sym.info, paramType.sym)
if tfWildcard in paramType.flags:
paramType.flags.excl tfWildcard
paramType.sym.transitionGenericParamToType()
else: discard
else: result = nil
proc semParamType(c: PContext, n: PNode, constraint: var PNode): PType =
## Semchecks the type of parameters.
@@ -1369,9 +1379,11 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
onDef(a[j].info, arg)
a[j] = newSymNode(arg)
var r: PType
if n[0].kind != nkEmpty:
r = semTypeNode(c, n[0], nil)
var r: PType =
if n[0].kind != nkEmpty:
semTypeNode(c, n[0], nil)
else:
nil
if r != nil and kind in {skMacro, skTemplate} and r.kind == tyTyped:
# XXX: To implement the proposed change in the warning, just
@@ -1568,6 +1580,8 @@ proc maybeAliasType(c: PContext; typeExpr, prev: PType): PType =
result.sym = prev.sym
if prev.kind != tyGenericBody:
assignType(prev, result)
else:
result = nil
proc fixupTypeOf(c: PContext, prev: PType, typExpr: PNode) =
if prev != nil:
@@ -1677,6 +1691,7 @@ proc semTypeClass(c: PContext, n: PNode, prev: PType): PType =
closeScope(c)
proc applyTypeSectionPragmas(c: PContext; pragmas, operand: PNode): PNode =
result = nil
for p in pragmas:
let key = if p.kind in nkPragmaCallKinds and p.len >= 1: p[0] else: p
@@ -2251,7 +2266,7 @@ proc semGenericParamList(c: PContext, n: PNode, father: PType = nil): PNode =
of nkIdentDefs:
var def = a[^1]
let constraint = a[^2]
var typ: PType
var typ: PType = nil
if constraint.kind != nkEmpty:
typ = semTypeNode(c, constraint, nil)

3
compiler/semtypinst.nim
View File

@@ -36,6 +36,7 @@ proc checkConstructedType*(conf: ConfigRef; info: TLineInfo, typ: PType) =
localError(info, errInheritanceOnlyWithNonFinalObjects)
proc searchInstTypes*(g: ModuleGraph; key: PType): PType =
result = nil
let genericTyp = key[0]
if not (genericTyp.kind == tyGenericBody and
genericTyp.sym != nil): return
@@ -100,6 +101,7 @@ proc newTypeMapLayer*(cl: var TReplTypeVars): LayeredIdTable =
initIdTable(result.topLayer)
proc lookup(typeMap: LayeredIdTable, key: PType): PType =
result = nil
var tm = typeMap
while tm != nil:
result = PType(idTableGet(tm.topLayer, key))
@@ -683,6 +685,7 @@ proc replaceTypeVarsTAux(cl: var TReplTypeVars, t: PType): PType =
proc initTypeVars*(p: PContext, typeMap: LayeredIdTable, info: TLineInfo;
owner: PSym): TReplTypeVars =
result = default(TReplTypeVars)
initIdTable(result.symMap)
initIdTable(result.localCache)
result.typeMap = typeMap

8
compiler/sighashes.nim
View File

@@ -159,7 +159,7 @@ proc hashType(c: var MD5Context, t: PType; flags: set[ConsiderFlag]; conf: Confi
else:
c.hashSym(t.sym)
var symWithFlags: PSym
var symWithFlags: PSym = nil
template hasFlag(sym): bool =
let ret = {sfAnon, sfGenSym} * sym.flags != {}
if ret: symWithFlags = sym
@@ -260,6 +260,7 @@ when defined(debugSigHashes):
# (select hash from sighashes group by hash having count(*) > 1) order by hash;
proc hashType*(t: PType; conf: ConfigRef; flags: set[ConsiderFlag] = {CoType}): SigHash =
result = default(SigHash)
var c: MD5Context
md5Init c
hashType c, t, flags+{CoOwnerSig}, conf
@@ -269,6 +270,7 @@ proc hashType*(t: PType; conf: ConfigRef; flags: set[ConsiderFlag] = {CoType}):
typeToString(t), $result)
proc hashProc(s: PSym; conf: ConfigRef): SigHash =
result = default(SigHash)
var c: MD5Context
md5Init c
hashType c, s.typ, {CoProc}, conf
@@ -289,6 +291,7 @@ proc hashProc(s: PSym; conf: ConfigRef): SigHash =
md5Final c, result.MD5Digest
proc hashNonProc*(s: PSym): SigHash =
result = default(SigHash)
var c: MD5Context
md5Init c
hashSym(c, s)
@@ -305,6 +308,7 @@ proc hashNonProc*(s: PSym): SigHash =
md5Final c, result.MD5Digest
proc hashOwner*(s: PSym): SigHash =
result = default(SigHash)
var c: MD5Context
md5Init c
var m = s
@@ -374,7 +378,7 @@ proc symBodyDigest*(graph: ModuleGraph, sym: PSym): SigHash =
## compute unique digest of the proc/func/method symbols
## recursing into invoked symbols as well
assert(sym.kind in skProcKinds, $sym.kind)
result = default(SigHash)
graph.symBodyHashes.withValue(sym.id, value):
return value[]

25
compiler/sigmatch.nim
View File

@@ -170,9 +170,11 @@ proc initCandidate*(ctx: PContext, c: var TCandidate, callee: PSym,
proc newCandidate*(ctx: PContext, callee: PSym,
binding: PNode, calleeScope = -1): TCandidate =
result = default(TCandidate)
initCandidate(ctx, result, callee, binding, calleeScope)
proc newCandidate*(ctx: PContext, callee: PType): TCandidate =
result = default(TCandidate)
initCandidate(ctx, result, callee)
proc copyCandidate(a: var TCandidate, b: TCandidate) =
@@ -214,6 +216,7 @@ proc sumGeneric(t: PType): int =
# count the "genericness" so that Foo[Foo[T]] has the value 3
# and Foo[T] has the value 2 so that we know Foo[Foo[T]] is more
# specific than Foo[T].
result = 0
var t = t
var isvar = 0
while true:
@@ -344,6 +347,7 @@ template describeArgImpl(c: PContext, n: PNode, i: int, startIdx = 1; prefer = p
result.add argTypeToString(arg, prefer)
proc describeArg*(c: PContext, n: PNode, i: int, startIdx = 1; prefer = preferName): string =
result = ""
describeArgImpl(c, n, i, startIdx, prefer)
proc describeArgs*(c: PContext, n: PNode, startIdx = 1; prefer = preferName): string =
@@ -440,6 +444,8 @@ proc isConvertibleToRange(c: PContext, f, a: PType): bool =
# `isIntLit` is correct and should be used above as well, see PR:
# https://github.com/nim-lang/Nim/pull/11197
result = isIntLit(a) or a.kind in {tyFloat..tyFloat128}
else:
result = false
proc handleFloatRange(f, a: PType): TTypeRelation =
if a.kind == f.kind:
@@ -506,6 +512,7 @@ proc skipToObject(t: PType; skipped: var SkippedPtr): PType =
else:
break
if r.kind == tyObject and ptrs <= 1: result = r
else: result = nil
proc isGenericSubtype(c: var TCandidate; a, f: PType, d: var int, fGenericOrigin: PType): bool =
assert f.kind in {tyGenericInst, tyGenericInvocation, tyGenericBody}
@@ -528,6 +535,8 @@ proc isGenericSubtype(c: var TCandidate; a, f: PType, d: var int, fGenericOrigin
genericParamPut(c, last, fGenericOrigin)
d = depth
result = true
else:
result = false
proc minRel(a, b: TTypeRelation): TTypeRelation =
if a <= b: result = a
@@ -609,6 +618,8 @@ proc procParamTypeRel(c: var TCandidate, f, a: PType): TTypeRelation =
if reverseRel >= isGeneric:
result = isInferred
#inc c.genericMatches
else:
result = isNone
else:
# Note that this typeRel call will save f's resolved type into c.bindings
# if f is metatype.
@@ -656,7 +667,7 @@ proc procTypeRel(c: var TCandidate, f, a: PType): TTypeRelation =
of tyNil:
result = f.allowsNil
else: discard
else: result = isNone
proc typeRangeRel(f, a: PType): TTypeRelation {.noinline.} =
template checkRange[T](a0, a1, f0, f1: T): TTypeRelation =
@@ -701,14 +712,14 @@ proc matchUserTypeClass*(m: var TCandidate; ff, a: PType): PType =
typeClass[0][0] = prevCandidateType
closeScope(c)
var typeParams: seq[(PSym, PType)]
var typeParams: seq[(PSym, PType)] = @[]
if ff.kind == tyUserTypeClassInst:
for i in 1..<(ff.len - 1):
var
typeParamName = ff.base[i-1].sym.name
typ = ff[i]
param: PSym
param: PSym = nil
alreadyBound = PType(idTableGet(m.bindings, typ))
if alreadyBound != nil: typ = alreadyBound
@@ -748,8 +759,8 @@ proc matchUserTypeClass*(m: var TCandidate; ff, a: PType): PType =
addDecl(c, param)
var
oldWriteHook: typeof(m.c.config.writelnHook)
diagnostics: seq[string]
oldWriteHook = default typeof(m.c.config.writelnHook)
diagnostics: seq[string] = @[]
errorPrefix: string
flags: TExprFlags = {}
collectDiagnostics = m.diagnosticsEnabled or
@@ -923,6 +934,7 @@ proc inferStaticsInRange(c: var TCandidate,
else:
failureToInferStaticParam(c.c.config, exp)
result = isNone
if lowerBound.kind == nkIntLit:
if upperBound.kind == nkIntLit:
if lengthOrd(c.c.config, concrete) == upperBound.intVal - lowerBound.intVal + 1:
@@ -2465,7 +2477,7 @@ proc matchesAux(c: PContext, n, nOrig: PNode, m: var TCandidate, marker: var Int
a = 1 # iterates over the actual given arguments
f = if m.callee.kind != tyGenericBody: 1
else: 0 # iterates over formal parameters
arg: PNode # current prepared argument
arg: PNode = nil # current prepared argument
formalLen = m.callee.n.len
formal = if formalLen > 1: m.callee.n[1].sym else: nil # current routine parameter
container: PNode = nil # constructed container
@@ -2726,6 +2738,7 @@ proc instTypeBoundOp*(c: PContext; dc: PSym; t: PType; info: TLineInfo;
else:
if f.kind in {tyVar}: f = f.lastSon
if typeRel(m, f, t) == isNone:
result = nil
localError(c.config, info, "cannot instantiate: '" & dc.name.s & "'")
else:
result = c.semGenerateInstance(c, dc, m.bindings, info)

1
compiler/sizealignoffsetimpl.nim
View File

@@ -503,6 +503,7 @@ template foldOffsetOf*(conf: ConfigRef; n: PNode; fallback: PNode): PNode =
elif node[1].kind == nkCheckedFieldExpr:
dotExpr = node[1][0]
else:
dotExpr = nil
localError(config, node.info, "can't compute offsetof on this ast")
assert dotExpr != nil

14
compiler/sourcemap.nim
View File

@@ -70,6 +70,7 @@ func encode*(values: seq[int]): string {.raises: [].} =
shift = 5
continueBit = 1 shl 5
mask = continueBit - 1
result = ""
for val in values:
# Sign is stored in first bit
var newVal = abs(val) shl 1
@@ -101,8 +102,8 @@ iterator tokenize*(line: string): (int, string) =
token = ""
while col < line.len:
var
token: string
name: string
token: string = ""
name: string = ""
# First we find the next identifier
col += line.skipWhitespace(col)
col += line.skipUntil(IdentStartChars, col)
@@ -110,7 +111,7 @@ iterator tokenize*(line: string): (int, string) =
col += line.parseIdent(token, col)
# Idents will either be originalName_randomInt or HEXhexCode_randomInt
if token.startsWith("HEX"):
var hex: int
var hex: int = 0
# 3 = "HEX".len and we only want to parse the two integers after it
discard token[3 ..< 5].parseHex(hex)
name = $chr(hex)
@@ -125,6 +126,7 @@ iterator tokenize*(line: string): (int, string) =
func parse*(source: string): SourceInfo =
## Parses the JS output for embedded line info
## So it can convert those into a series of mappings
result = default(SourceInfo)
var
skipFirstLine = true
currColumn = 0
@@ -133,9 +135,9 @@ func parse*(source: string): SourceInfo =
# Add each line as a node into the output
for line in source.splitLines():
var
lineNumber: int
linePath: string
column: int
lineNumber: int = 0
linePath: string = ""
column: int = 0
if line.strip().scanf("/* line $i:$i \"$+\" */", lineNumber, column, linePath):
# When we reach the first line mappinsegmentg then we can assume
# we can map the rest of the JS lines to Nim lines

4
compiler/spawn.nim
View File

@@ -114,7 +114,7 @@ proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
idgen: IdGenerator;
spawnKind: TSpawnResult, result: PSym) =
var body = newNodeI(nkStmtList, f.info)
var threadLocalBarrier: PSym
var threadLocalBarrier: PSym = nil
if barrier != nil:
var varSection2 = newNodeI(nkVarSection, barrier.info)
threadLocalBarrier = addLocalVar(g, varSection2, nil, idgen, result,
@@ -122,7 +122,7 @@ proc createWrapperProc(g: ModuleGraph; f: PNode; threadParam, argsParam: PSym;
body.add varSection2
body.add callCodegenProc(g, "barrierEnter", threadLocalBarrier.info,
threadLocalBarrier.newSymNode)
var threadLocalProm: PSym
var threadLocalProm: PSym = nil
if spawnKind == srByVar:
threadLocalProm = addLocalVar(g, varSection, nil, idgen, result, fv.typ, fv)
elif fv != nil:

33
compiler/suggest.nim
View File

@@ -55,6 +55,8 @@ proc findDocComment(n: PNode): PNode =
result = findDocComment(n[1])
elif n.kind in {nkAsgn, nkFastAsgn, nkSinkAsgn} and n.len == 2:
result = findDocComment(n[1])
else:
result = nil
proc extractDocComment(g: ModuleGraph; s: PSym): string =
var n = findDocComment(s.ast)
@@ -106,7 +108,7 @@ proc getTokenLenFromSource(conf: ConfigRef; ident: string; info: TLineInfo): int
if cmpIgnoreStyle(line[column..column + result - 1], ident) != 0:
result = 0
else:
var sourceIdent: string
var sourceIdent: string = ""
result = parseWhile(line, sourceIdent,
OpChars + {'[', '(', '{', ']', ')', '}'}, column)
if ident[^1] == '=' and ident[0] in linter.Letters:
@@ -254,13 +256,17 @@ proc filterSym(s: PSym; prefix: PNode; res: var PrefixMatch): bool {.inline.} =
of nkOpenSymChoice, nkClosedSymChoice, nkAccQuoted:
if n.len > 0:
result = prefixMatch(s, n[0])
else: discard
else:
result = default(PrefixMatch)
else: result = default(PrefixMatch)
if s.kind != skModule:
if prefix != nil:
res = prefixMatch(s, prefix)
result = res != PrefixMatch.None
else:
result = true
else:
result = false
proc filterSymNoOpr(s: PSym; prefix: PNode; res: var PrefixMatch): bool {.inline.} =
result = filterSym(s, prefix, res) and s.name.s[0] in lexer.SymChars and
@@ -294,7 +300,7 @@ proc getQuality(s: PSym): range[0..100] =
result = result - 5
proc suggestField(c: PContext, s: PSym; f: PNode; info: TLineInfo; outputs: var Suggestions) =
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
if filterSym(s, f, pm) and fieldVisible(c, s):
outputs.add(symToSuggest(c.graph, s, isLocal=true, ideSug, info,
s.getQuality, pm, c.inTypeContext > 0, 0))
@@ -302,7 +308,7 @@ proc suggestField(c: PContext, s: PSym; f: PNode; info: TLineInfo; outputs: var
template wholeSymTab(cond, section: untyped) {.dirty.} =
for (item, scopeN, isLocal) in uniqueSyms(c):
let it = item
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
if cond:
outputs.add(symToSuggest(c.graph, it, isLocal = isLocal, section, info, getQuality(it),
pm, c.inTypeContext > 0, scopeN))
@@ -365,6 +371,8 @@ proc typeFits(c: PContext, s: PSym, firstArg: PType): bool {.inline.} =
if exp.kind == tyVarargs: exp = elemType(exp)
if exp.kind in {tyUntyped, tyTyped, tyGenericParam, tyAnything}: return
result = sigmatch.argtypeMatches(c, s.typ[1], firstArg)
else:
result = false
proc suggestOperations(c: PContext, n, f: PNode, typ: PType, outputs: var Suggestions) =
assert typ != nil
@@ -374,7 +382,7 @@ proc suggestOperations(c: PContext, n, f: PNode, typ: PType, outputs: var Sugges
proc suggestEverything(c: PContext, n, f: PNode, outputs: var Suggestions) =
# do not produce too many symbols:
for (it, scopeN, isLocal) in uniqueSyms(c):
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
if filterSym(it, f, pm):
outputs.add(symToSuggest(c.graph, it, isLocal = isLocal, ideSug, n.info,
it.getQuality, pm, c.inTypeContext > 0, scopeN))
@@ -383,7 +391,7 @@ proc suggestFieldAccess(c: PContext, n, field: PNode, outputs: var Suggestions)
# special code that deals with ``myObj.``. `n` is NOT the nkDotExpr-node, but
# ``myObj``.
var typ = n.typ
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
when defined(nimsuggest):
if n.kind == nkSym and n.sym.kind == skError and c.config.suggestVersion == 0:
# consider 'foo.|' where 'foo' is some not imported module.
@@ -445,7 +453,7 @@ proc suggestFieldAccess(c: PContext, n, field: PNode, outputs: var Suggestions)
for node in typ.n:
if node.kind == nkSym:
let s = node.sym
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
if filterSym(s, field, pm):
outputs.add(symToSuggest(c.graph, s, isLocal=true, ideSug, n.info,
s.getQuality, pm, c.inTypeContext > 0, 0))
@@ -460,17 +468,24 @@ type
proc inCheckpoint*(current, trackPos: TLineInfo): TCheckPointResult =
if current.fileIndex == trackPos.fileIndex:
result = cpNone
if current.line == trackPos.line and
abs(current.col-trackPos.col) < 4:
return cpExact
if current.line >= trackPos.line:
return cpFuzzy
else:
result = cpNone
proc isTracked*(current, trackPos: TLineInfo, tokenLen: int): bool =
if current.fileIndex==trackPos.fileIndex and current.line==trackPos.line:
let col = trackPos.col
if col >= current.col and col <= current.col+tokenLen-1:
return true
result = true
else:
result = false
else:
result = false
when defined(nimsuggest):
# Since TLineInfo defined a == operator that doesn't include the column,
@@ -700,7 +715,7 @@ proc suggestSentinel*(c: PContext) =
var outputs: Suggestions = @[]
# suggest everything:
for (it, scopeN, isLocal) in uniqueSyms(c):
var pm: PrefixMatch
var pm: PrefixMatch = default(PrefixMatch)
if filterSymNoOpr(it, nil, pm):
outputs.add(symToSuggest(c.graph, it, isLocal = isLocal, ideSug,
newLineInfo(c.config.m.trackPos.fileIndex, 0, -1), it.getQuality,

10
compiler/syntaxes.nim
View File

@@ -36,6 +36,8 @@ proc containsShebang(s: string, i: int): bool =
var j = i + 2
while j < s.len and s[j] in Whitespace: inc(j)
result = s[j] == '/'
else:
result = false
proc parsePipe(filename: AbsoluteFile, inputStream: PLLStream; cache: IdentCache;
config: ConfigRef): PNode =
@@ -64,6 +66,7 @@ proc parsePipe(filename: AbsoluteFile, inputStream: PLLStream; cache: IdentCache
llStreamClose(s)
proc getFilter(ident: PIdent): FilterKind =
result = filtNone
for i in FilterKind:
if cmpIgnoreStyle(ident.s, $i) == 0:
return i
@@ -74,6 +77,7 @@ proc getCallee(conf: ConfigRef; n: PNode): PIdent =
elif n.kind == nkIdent:
result = n.ident
else:
result = nil
localError(conf, n.info, "invalid filter: " & renderTree(n))
proc applyFilter(p: var Parser, n: PNode, filename: AbsoluteFile,
@@ -124,7 +128,7 @@ proc openParser*(p: var Parser, fileIdx: FileIndex, inputstream: PLLStream;
proc setupParser*(p: var Parser; fileIdx: FileIndex; cache: IdentCache;
config: ConfigRef): bool =
let filename = toFullPathConsiderDirty(config, fileIdx)
var f: File
var f: File = default(File)
if not open(f, filename.string):
rawMessage(config, errGenerated, "cannot open file: " & filename.string)
return false
@@ -132,7 +136,9 @@ proc setupParser*(p: var Parser; fileIdx: FileIndex; cache: IdentCache;
result = true
proc parseFile*(fileIdx: FileIndex; cache: IdentCache; config: ConfigRef): PNode =
var p: Parser
var p: Parser = default(Parser)
if setupParser(p, fileIdx, cache, config):
result = parseAll(p)
closeParser(p)
else:
result = nil

8
compiler/transf.nim
View File

@@ -242,9 +242,10 @@ proc transformConstSection(c: PTransf, v: PNode): PNode =
proc hasContinue(n: PNode): bool =
case n.kind
of nkEmpty..nkNilLit, nkForStmt, nkParForStmt, nkWhileStmt: discard
of nkEmpty..nkNilLit, nkForStmt, nkParForStmt, nkWhileStmt: result = false
of nkContinueStmt: result = true
else:
result = false
for i in 0..<n.len:
if hasContinue(n[i]): return true
@@ -381,6 +382,7 @@ proc transformYield(c: PTransf, n: PNode): PNode =
of nkDotExpr:
result = newAsgnStmt(c, nkAsgn, lhs, rhs, false)
else:
result = nil
internalAssert c.graph.config, false
result = newTransNode(nkStmtList, n.info, 0)
var e = n[0]
@@ -832,7 +834,9 @@ proc getMergeOp(n: PNode): PSym =
nkCallStrLit:
if n[0].kind == nkSym and n[0].sym.magic == mConStrStr:
result = n[0].sym
else: discard
else:
result = nil
else: result = nil
proc flattenTreeAux(d, a: PNode, op: PSym) =
## Optimizes away the `&` calls in the children nodes and

21
compiler/trees.nim
View File

@@ -13,6 +13,7 @@ import
ast, wordrecg, idents
proc cyclicTreeAux(n: PNode, visited: var seq[PNode]): bool =
result = false
if n == nil: return
for v in visited:
if v == n: return true
@@ -53,8 +54,13 @@ proc exprStructuralEquivalent*(a, b: PNode; strictSymEquality=false): bool =
if not exprStructuralEquivalent(a[i], b[i],
strictSymEquality): return
result = true
else:
result = false
else:
result = false
proc sameTree*(a, b: PNode): bool =
result = false
if a == b:
result = true
elif a != nil and b != nil and a.kind == b.kind:
@@ -91,6 +97,7 @@ proc isConstExpr*(n: PNode): bool =
n.kind in atomKinds or nfAllConst in n.flags
proc isCaseObj*(n: PNode): bool =
result = false
if n.kind == nkRecCase: return true
for i in 0..<n.safeLen:
if n[i].isCaseObj: return true
@@ -117,7 +124,7 @@ proc isDeepConstExpr*(n: PNode; preventInheritance = false): bool =
result = true
else:
result = true
else: discard
else: result = false
proc isRange*(n: PNode): bool {.inline.} =
if n.kind in nkCallKinds:
@@ -127,6 +134,10 @@ proc isRange*(n: PNode): bool {.inline.} =
(callee.kind in {nkClosedSymChoice, nkOpenSymChoice} and
callee[1].sym.name.id == ord(wDotDot)):
result = true
else:
result = false
else:
result = false
proc whichPragma*(n: PNode): TSpecialWord =
let key = if n.kind in nkPragmaCallKinds and n.len > 0: n[0] else: n
@@ -145,12 +156,14 @@ proc isNoSideEffectPragma*(n: PNode): bool =
result = k == wNoSideEffect
proc findPragma*(n: PNode, which: TSpecialWord): PNode =
result = nil
if n.kind == nkPragma:
for son in n:
if whichPragma(son) == which:
return son
proc effectSpec*(n: PNode, effectType: TSpecialWord): PNode =
result = nil
for i in 0..<n.len:
var it = n[i]
if it.kind == nkExprColonExpr and whichPragma(it) == effectType:
@@ -161,6 +174,7 @@ proc effectSpec*(n: PNode, effectType: TSpecialWord): PNode =
return
proc propSpec*(n: PNode, effectType: TSpecialWord): PNode =
result = nil
for i in 0..<n.len:
var it = n[i]
if it.kind == nkExprColonExpr and whichPragma(it) == effectType:
@@ -194,6 +208,8 @@ proc getRoot*(n: PNode): PSym =
of nkSym:
if n.sym.kind in {skVar, skResult, skTemp, skLet, skForVar, skParam}:
result = n.sym
else:
result = nil
of nkDotExpr, nkBracketExpr, nkHiddenDeref, nkDerefExpr,
nkObjUpConv, nkObjDownConv, nkCheckedFieldExpr, nkHiddenAddr, nkAddr:
result = getRoot(n[0])
@@ -201,7 +217,8 @@ proc getRoot*(n: PNode): PSym =
result = getRoot(n[1])
of nkCallKinds:
if getMagic(n) == mSlice: result = getRoot(n[1])
else: discard
else: result = nil
else: result = nil
proc stupidStmtListExpr*(n: PNode): bool =
for i in 0..<n.len-1:

4
compiler/treetab.nim
View File

@@ -57,7 +57,11 @@ proc treesEquivalent(a, b: PNode): bool =
for i in 0..<a.len:
if not treesEquivalent(a[i], b[i]): return
result = true
else:
result = false
if result: result = sameTypeOrNil(a.typ, b.typ)
else:
result = false
proc nodeTableRawGet(t: TNodeTable, k: Hash, key: PNode): int =
var h: Hash = k and high(t.data)

2
compiler/typeallowed.nim
View File

@@ -47,6 +47,8 @@ proc typeAllowedNode(marker: var IntSet, n: PNode, kind: TSymKind,
let it = n[i]
result = typeAllowedNode(marker, it, kind, c, flags)
if result != nil: break
else:
result = nil
proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
c: PContext; flags: TTypeAllowedFlags = {}): PType =

48
compiler/types.nim
View File

@@ -214,6 +214,8 @@ proc iterOverNode(marker: var IntSet, n: PNode, iter: TTypeIter,
for i in 0..<n.len:
result = iterOverNode(marker, n[i], iter, closure)
if result: return
else:
result = false
proc iterOverTypeAux(marker: var IntSet, t: PType, iter: TTypeIter,
closure: RootRef): bool =
@@ -786,7 +788,7 @@ proc firstOrd*(conf: ConfigRef; t: PType): Int128 =
of 4: result = toInt128(-2147483648)
of 2: result = toInt128(-32768)
of 1: result = toInt128(-128)
else: discard
else: result = Zero
else:
result = toInt128(0x8000000000000000'i64)
of tyInt8: result = toInt128(-128)
@@ -802,17 +804,21 @@ proc firstOrd*(conf: ConfigRef; t: PType): Int128 =
if t.n.len > 0:
assert(t.n[0].kind == nkSym)
result = toInt128(t.n[0].sym.position)
else:
result = Zero
of tyGenericInst, tyDistinct, tyTypeDesc, tyAlias, tySink,
tyStatic, tyInferred, tyUserTypeClasses, tyLent:
result = firstOrd(conf, lastSon(t))
of tyOrdinal:
if t.len > 0: result = firstOrd(conf, lastSon(t))
else: internalError(conf, "invalid kind for firstOrd(" & $t.kind & ')')
else:
result = Zero
internalError(conf, "invalid kind for firstOrd(" & $t.kind & ')')
of tyUncheckedArray, tyCstring:
result = Zero
else:
internalError(conf, "invalid kind for firstOrd(" & $t.kind & ')')
result = Zero
internalError(conf, "invalid kind for firstOrd(" & $t.kind & ')')
proc firstFloat*(t: PType): BiggestFloat =
case t.kind
@@ -834,14 +840,14 @@ proc targetSizeSignedToKind*(conf: ConfigRef): TTypeKind =
of 8: result = tyInt64
of 4: result = tyInt32
of 2: result = tyInt16
else: discard
else: result = tyNone
proc targetSizeUnsignedToKind*(conf: ConfigRef): TTypeKind =
case conf.target.intSize
of 8: result = tyUInt64
of 4: result = tyUInt32
of 2: result = tyUInt16
else: discard
else: result = tyNone
proc normalizeKind*(conf: ConfigRef, k: TTypeKind): TTypeKind =
case k
@@ -869,7 +875,7 @@ proc lastOrd*(conf: ConfigRef; t: PType): Int128 =
of 4: result = toInt128(0x7FFFFFFF)
of 2: result = toInt128(0x00007FFF)
of 1: result = toInt128(0x0000007F)
else: discard
else: result = Zero
else: result = toInt128(0x7FFFFFFFFFFFFFFF'u64)
of tyInt8: result = toInt128(0x0000007F)
of tyInt16: result = toInt128(0x00007FFF)
@@ -889,18 +895,22 @@ proc lastOrd*(conf: ConfigRef; t: PType): Int128 =
if t.n.len > 0:
assert(t.n[^1].kind == nkSym)
result = toInt128(t.n[^1].sym.position)
else:
result = Zero
of tyGenericInst, tyDistinct, tyTypeDesc, tyAlias, tySink,
tyStatic, tyInferred, tyUserTypeClasses, tyLent:
result = lastOrd(conf, lastSon(t))
of tyProxy: result = Zero
of tyOrdinal:
if t.len > 0: result = lastOrd(conf, lastSon(t))
else: internalError(conf, "invalid kind for lastOrd(" & $t.kind & ')')
else:
result = Zero
internalError(conf, "invalid kind for lastOrd(" & $t.kind & ')')
of tyUncheckedArray:
result = Zero
else:
internalError(conf, "invalid kind for lastOrd(" & $t.kind & ')')
result = Zero
internalError(conf, "invalid kind for lastOrd(" & $t.kind & ')')
proc lastFloat*(t: PType): BiggestFloat =
case t.kind
@@ -972,7 +982,7 @@ type
proc initSameTypeClosure: TSameTypeClosure =
# we do the initialization lazily for performance (avoids memory allocations)
discard
result = TSameTypeClosure()
proc containsOrIncl(c: var TSameTypeClosure, a, b: PType): bool =
result = c.s.len > 0 and c.s.contains((a.id, b.id))
@@ -1011,6 +1021,8 @@ proc equalParam(a, b: PSym): TParamsEquality =
result = paramsEqual
elif b.ast != nil:
result = paramsIncompatible
else:
result = paramsNotEqual
else:
result = paramsNotEqual
@@ -1078,6 +1090,8 @@ proc sameTuple(a, b: PType, c: var TSameTypeClosure): bool =
return false
elif a.n != b.n and (a.n == nil or b.n == nil) and IgnoreTupleFields notin c.flags:
result = false
else:
result = false
template ifFastObjectTypeCheckFailed(a, b: PType, body: untyped) =
if tfFromGeneric notin a.flags + b.flags:
@@ -1097,6 +1111,8 @@ template ifFastObjectTypeCheckFailed(a, b: PType, body: untyped) =
if tfFromGeneric in a.flags * b.flags and a.sym.id == b.sym.id:
# ok, we need the expensive structural check
body
else:
result = false
proc sameObjectTypes*(a, b: PType): bool =
# specialized for efficiency (sigmatch uses it)
@@ -1134,6 +1150,12 @@ proc sameObjectTree(a, b: PNode, c: var TSameTypeClosure): bool =
for i in 0..<a.len:
if not sameObjectTree(a[i], b[i], c): return
result = true
else:
result = false
else:
result = false
else:
result = false
proc sameObjectStructures(a, b: PType, c: var TSameTypeClosure): bool =
# check base types:
@@ -1160,6 +1182,7 @@ proc sameFlags*(a, b: PType): bool {.inline.} =
result = eqTypeFlags*a.flags == eqTypeFlags*b.flags
proc sameTypeAux(x, y: PType, c: var TSameTypeClosure): bool =
result = false
template cycleCheck() =
# believe it or not, the direct check for ``containsOrIncl(c, a, b)``
# increases bootstrapping time from 2.4s to 3.3s on my laptop! So we cheat
@@ -1338,6 +1361,7 @@ proc inheritanceDiff*(a, b: PType): int =
result = high(int)
proc commonSuperclass*(a, b: PType): PType =
result = nil
# quick check: are they the same?
if sameObjectTypes(a, b): return a
@@ -1451,6 +1475,7 @@ proc compatibleExceptions(se, re: PNode): bool =
result = true
proc hasIncompatibleEffect(se, re: PNode): bool =
result = false
if re.isNil: return false
for r in items(re):
for s in items(se):
@@ -1789,6 +1814,7 @@ proc isSinkTypeForParam*(t: PType): bool =
result = true
proc lookupFieldAgain*(ty: PType; field: PSym): PSym =
result = nil
var ty = ty
while ty != nil:
ty = ty.skipTypes(skipPtrs)
@@ -1811,7 +1837,9 @@ proc isCharArrayPtr*(t: PType; allowPointerToChar: bool): bool =
of tyChar:
result = allowPointerToChar
else:
discard
result = false
else:
result = false
proc lacksMTypeField*(typ: PType): bool {.inline.} =
(typ.sym != nil and sfPure in typ.sym.flags) or tfFinal in typ.flags

1
compiler/typesrenderer.nim
View File

@@ -99,6 +99,7 @@ proc renderType(n: PNode, toNormalize: bool): string =
proc renderParamNames*(n: PNode, toNormalize=false): seq[string] =
## Returns parameter names of routine `n`.
result = @[]
doAssert n.kind == nkFormalParams
case n.kind
of nkFormalParams:

Some files were not shown because too many files have changed in this diff Show More