# # # The Nim Compiler # (c) Copyright 2017 Andreas Rumpf # # See the file "copying.txt", included in this # distribution, for details about the copyright. # import ast, renderer, msgs, options, lineinfos, idents, treetab import std/[intsets, tables, sequtils, strutils, sets, strformat, hashes] when defined(nimPreviewSlimSystem): import std/assertions # IMPORTANT: notes not up to date, i'll update this comment again # # notes: # # Env: int => nilability # a = b # nilability a <- nilability b # deref a # if Nil error is nil # if MaybeNil error might be nil, hint add if isNil # if Safe fine # fun(arg: A) # nilability arg <- for ref MaybeNil, for not nil or others Safe # map is env? # a or b # each one forks a different env # result = union(envL, envR) # a and b # b forks a's env # if a: code # result = union(previousEnv after not a, env after code) # if a: b else: c # result = union(env after b, env after c) # result = b # nilability result <- nilability b, if return type is not nil and result not safe, error # return b # as result = b # try: a except: b finally: c # in b and c env is union of all possible try first n lines, after union of a and b and c # keep in mind canRaise and finally # case a: of b: c # similar to if # call(arg) # if it returns ref, assume it's MaybeNil: hint that one can add not nil to the return type # call(var arg) # zahary comment # if arg is ref, assume it's MaybeNil after call # loop # union of env for 0, 1, 2 iterations as Herb Sutter's paper # why 2? # return # if something: stop (break return etc) # is equivalent to if something: .. else: remain # new(ref) # ref becomes Safe # objConstr(a: b) # returns safe # each check returns its nilability and map type SeqOfDistinct[T, U] = distinct seq[U] # TODO use distinct base type instead of int? func `[]`[T, U](a: SeqOfDistinct[T, U], index: T): U = (seq[U])(a)[index.int] proc `[]=`[T, U](a: var SeqOfDistinct[T, U], index: T, value: U) = ((seq[U])(a))[index.int] = value func `[]`[T, U](a: var SeqOfDistinct[T, U], index: T): var U = (seq[U])(a)[index.int] func len[T, U](a: SeqOfDistinct[T, U]): T = (seq[U])(a).len.T func low[T, U](a: SeqOfDistinct[T, U]): T = (seq[U])(a).low.T func high[T, U](a: SeqOfDistinct[T, U]): T = (seq[U])(a).high.T proc setLen[T, U](a: var SeqOfDistinct[T, U], length: T) = ((seq[U])(a)).setLen(length.Natural) proc newSeqOfDistinct[T, U](length: T = 0.T): SeqOfDistinct[T, U] = (SeqOfDistinct[T, U])(newSeq[U](length.int)) func newSeqOfDistinct[T, U](length: int = 0): SeqOfDistinct[T, U] = # newSeqOfDistinct(length.T) # ? newSeqOfDistinct[T, U](length.T) (SeqOfDistinct[T, U])(newSeq[U](length)) iterator items[T, U](a: SeqOfDistinct[T, U]): U = for element in (seq[U])(a): yield element iterator pairs[T, U](a: SeqOfDistinct[T, U]): (T, U) = for i, element in (seq[U])(a): yield (i.T, element) func `$`[T, U](a: SeqOfDistinct[T, U]): string = $((seq[U])(a)) proc add*[T, U](a: var SeqOfDistinct[T, U], value: U) = ((seq[U])(a)).add(value) type ## a hashed representation of a node: should be equal for structurally equal nodes Symbol = distinct int ## the index of an expression in the pre-indexed sequence of those ExprIndex = distinct int16 ## the set index SetIndex = distinct int ## transition kind: ## what was the reason for changing the nilability of an expression ## useful for error messages and showing why an expression is being detected as nil / maybe nil TransitionKind = enum TArg, TAssign, TType, TNil, TVarArg, TResult, TSafe, TPotentialAlias, TDependant ## keep history for each transition History = object info: TLineInfo ## the location nilability: Nilability ## the nilability kind: TransitionKind ## what kind of transition was that node: PNode ## the node of the expression ## the context for the checker: an instance for each procedure NilCheckerContext = ref object # abstractTime: AbstractTime # partitions: Partitions # symbolGraphs: Table[Symbol, ] symbolIndices: Table[Symbol, ExprIndex] ## index for each symbol expressions: SeqOfDistinct[ExprIndex, PNode] ## a sequence of pre-indexed expressions dependants: SeqOfDistinct[ExprIndex, IntSet] ## expr indices for expressions which are compound and based on others warningLocations: HashSet[TLineInfo] ## warning locations to check we don't warn twice for stuff like warnings in for loops idgen: IdGenerator ## id generator config: ConfigRef ## the config of the compiler ## a map that is containing the current nilability for usually a branch ## and is pointing optionally to a parent map: they make a stack of maps NilMap = ref object expressions: SeqOfDistinct[ExprIndex, Nilability] ## the expressions with the same order as in NilCheckerContext history: SeqOfDistinct[Expr
# dwm - dynamic window manager
# © 2006-2007 Anselm R. Garbe, Sander van Dijk

include config.mk

SRC = client.c draw.c event.c layout.c main.c tag.c util.c
OBJ = ${SRC:.c=.o}

all: options dwm

options:
	@echo dwm build options:
	@echo "CFLAGS   = ${CFLAGS}"
	@echo "LDFLAGS  = ${LDFLAGS}"
	@echo "CC       = ${CC}"

.c.o:
	@echo CC $<
	@${CC} -c ${CFLAGS} $<

${OBJ}: dwm.h config.h config.mk

config.h:
	@echo creating $@ from config.default.h
	@cp config.default.h $@

dwm: ${OBJ}
	@echo CC -o $@
	@${CC} -o $@ ${OBJ} ${LDFLAGS}
	@strip $@

clean:
	@echo cleaning
	@rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz

dist: clean
	@echo creating dist tarball
	@mkdir -p dwm-${VERSION}
	@cp -R LICENSE Makefile README config.*.h config.mk \
		dwm.1 dwm.h ${SRC} dwm-${VERSION}
	@tar -cf dwm-${VERSION}.tar dwm-${VERSION}
	@gzip dwm-${VERSION}.tar
	@rm -rf dwm-${VERSION}

install: all
	@echo installing executable file to ${DESTDIR}${PREFIX}/bin
	@mkdir -p ${DESTDIR}${PREFIX}/bin
	@cp -f dwm ${DESTDIR}${PREFIX}/bin
	@chmod 755 ${DESTDIR}${PREFIX}/bin/dwm
	@echo installing manual page to ${DESTDIR}${MANPREFIX}/man1
	@mkdir -p ${DESTDIR}${MANPREFIX}/man1
	@sed "s/VERSION/${VERSION}/g" < dwm.1 > ${DESTDIR}${MANPREFIX}/man1/dwm.1
	@chmod 644 ${DESTDIR}${MANPREFIX}/man1/dwm.1

uninstall:
	@echo removing executable file from ${DESTDIR}${PREFIX}/bin
	@rm -f ${DESTDIR}${PREFIX}/bin/dwm
	@echo removing manual page from ${DESTDIR}${MANPREFIX}/man1
	@rm -f ${DESTDIR}${MANPREFIX}/man1/dwm.1

.PHONY: all options clean dist install uninstall
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-07-23 18:27:49 +0000
if n.kind in {nkSym, nkDotExpr} or isConstBracket(n): let key = ctx.index(n) result.nilability = result.map[key] elif n.kind == nkBracketExpr: # sometimes false positive result.nilability = MaybeNil else: # sometimes maybe false positive result.nilability = MaybeNil proc checkDotExpr(n, ctx, map): Check = ## check dot expressions: make sure we can dereference the base result = check(n[0], ctx, map) result = checkRefExpr(n, ctx, result) proc checkBracketExpr(n, ctx, map): Check = ## check bracket expressions: make sure we can dereference the base result = check(n[0], ctx, map) # if might be deref: [] == *(a + index) for cstring handleNilability(result, n[0], ctx, map) result = check(n[1], ctx, result.map) result = checkRefExpr(n, ctx, result) # echo n, " ", result.nilability template union(l: Nilability, r: Nilability): Nilability = ## unify two states if l == r: l else: MaybeNil template add(l: Nilability, r: Nilability): Nilability = if l == r: # Safe Safe -> Safe etc l elif l == Parent: # Parent Safe -> Safe etc r elif r == Parent: # Safe Parent -> Safe etc l elif l == Unreachable or r == Unreachable: # Safe Unreachable -> Unreachable etc Unreachable elif l == MaybeNil: # Safe MaybeNil -> Safe etc r elif r == MaybeNil: # MaybeNil Nil -> Nil etc l else: # Safe Nil -> Unreachable etc Unreachable proc findCommonParent(l: NilMap, r: NilMap): NilMap = result = l.parent while not result.isNil: var rparent = r.parent while not rparent.isNil: if result == rparent: return result rparent = rparent.parent result = result.parent proc union(ctx: NilCheckerContext, l: NilMap, r: NilMap): NilMap = ## unify two maps from different branches ## combine their locals ## what if they are from different parts of the same tree ## e.g. ## a -> b -> c ## -> b1 ## common then? ## if l.isNil: return r elif r.isNil: return l let common = findCommonParent(l, r) result = newNilMap(common, ctx.expressions.len.int) for index, value in l: let h = history(r, index) let info = if h.len > 0: h[^1].info else: TLineInfo(line: 0) # assert h.len > 0 # echo "history", name, value, r[name], h[^1].info.line result.store(ctx, index, union(value, r[index]), TAssign, info) proc add(ctx: NilCheckerContext, l: NilMap, r: NilMap): NilMap = #echo "add " #echo namedMapDebugInfo(ctx, l) #echo " : " #echo namedMapDebugInfo(ctx, r) if l.isNil: return r elif r.isNil: return l let common = findCommonParent(l, r) result = newNilMap(common, ctx.expressions.len.int) for index, value in l: let h = history(r, index) let info = if h.len > 0: h[^1].info else: TLineInfo(line: 0) # TODO: refactor and also think: is TAssign a good one result.store(ctx, index, add(value, r[index]), TAssign, info) #echo "result" #echo namedMapDebugInfo(ctx, result) #echo "" #echo "" proc checkAsgn(target: PNode, assigned: PNode; ctx, map): Check = ## check assignment ## update map based on `assigned` if assigned.kind != nkEmpty: result = check(assigned, ctx, map) else: result = Check(nilability: typeNilability(target.typ), map: map) # we need to visit and check those, but we don't use the result for now # is it possible to somehow have another event happen here? discard check(target, ctx, map) if result.map.isNil: result.map = map if target.kind in {nkSym, nkDotExpr} or isConstBracket(target): let t = ctx.index(target) move(ctx, map, target, assigned) case assigned.kind: of nkNilLit: result.map.store(ctx, t, Nil, TAssign, target.info, target) else: result.map.store(ctx, t, result.nilability, TAssign, target.info, target) moveOutDependants(ctx, map, target) storeDependants(ctx, map, target, MaybeNil) if assigned.kind in {nkObjConstr, nkTupleConstr}: for (element, value) in result.elements: var elementNode = nkDotExpr.newTree(nkHiddenDeref.newTree(target), element) if symbol(elementNode) in ctx.symbolIndices: var elementIndex = ctx.index(elementNode) result.map.store(ctx, elementIndex, value, TAssign, target.info, elementNode) proc checkReturn(n, ctx, map): Check = ## check return # return n same as result = n; return ? result = check(n[0], ctx, map) result.map.store(ctx, resultExprIndex, result.nilability, TAssign, n.info) proc checkIf(n, ctx, map): Check = ## check branches based on condition result = default(Check) var mapIf: NilMap = map # first visit the condition # the structure is not If(Elif(Elif, Else), Else) # it is # If(Elif, Elif, Else) var mapCondition = checkCondition(n.sons[0].sons[0], ctx, mapIf, false, true) # the state of the conditions: negating conditions before the current one var layerHistory = newNilMap(mapIf) # the state after branch effects var afterLayer: NilMap = nil # the result nilability for expressions var nilability = Safe for branch in n.sons: var branchConditionLayer = newNilMap(layerHistory) var branchLayer: NilMap var code: PNode if branch.kind in {nkIfStmt, nkElifBranch}: var mapCondition = checkCondition(branch[0], ctx, branchConditionLayer, false, true) let reverseMapCondition = reverseDirect(mapCondition) layerHistory = ctx.add(layerHistory, reverseMapCondition) branchLayer = mapCondition code = branch[1] else: branchLayer = layerHistory code = branch let branchCheck = checkBranch(code, ctx, branchLayer) # handles nil afterLayer -> returns branchCheck.map afterLayer = ctx.union(afterLayer, branchCheck.map) nilability = if n.kind == nkIfStmt: Safe else: union(nilability, branchCheck.nilability) if n.sons.len > 1: result.map = afterLayer result.nilability = nilability else: if not hasUnstructuredControlFlowJump(n[0][1]): # here it matters what happend inside, because # we might continue in the parent branch after entering this one # either we enter the branch, so we get mapIf and effect of branch -> afterLayer # or we dont , so we get mapIf and (not condition) effect -> layerHistory result.map = ctx.union(layerHistory, afterLayer) result.nilability = Safe # no expr? else: # similar to else: because otherwise we are jumping out of # the branch, so no union with the mapIf (we dont continue if the condition was true) # here it also doesn't matter for the parent branch what happened in the branch, e.g. assigning to nil # as if we continue there, we haven't entered the branch probably # so we don't do an union with afterLayer # layerHistory has the effect of mapIf and (not condition) result.map = layerHistory result.nilability = Safe proc checkFor(n, ctx, map): Check = ## check for loops ## try to repeat the unification of the code twice ## to detect what can change after a several iterations ## approach based on discussions with Zahary/Araq ## similar approach used for other loops var m = map.copyMap() var map0 = map.copyMap() #echo namedMapDebugInfo(ctx, map) m = check(n.sons[2], ctx, map).map.copyMap() if n[0].kind == nkSym: m.store(ctx, ctx.index(n[0]), typeNilability(n[0].typ), TAssign, n[0].info) # echo namedMapDebugInfo(ctx, map) var check2 = check(n.sons[2], ctx, m) var map2 = check2.map result = Check(map: ctx.union(map0, m)) result.map = ctx.union(result.map, map2) result.nilability = Safe # check: # while code: # code2 # if code: # code2 # if code: # code2 # if code: # code2 # check(code), check(code2 in code's map) proc checkWhile(n, ctx, map): Check = ## check while loops ## try to repeat the unification of the code twice var m = checkCondition(n[0], ctx, map, false, false) var map0 = map.copyMap() m = check(n.sons[1], ctx, m).map var map1 = m.copyMap() var check2 = check(n.sons[1], ctx, m) var map2 = check2.map result = Check(map: ctx.union(map0, map1)) result.map = ctx.union(result.map, map2) result.nilability = Safe proc checkInfix(n, ctx, map): Check = ## check infix operators in condition ## a and b : map is based on a; next b ## 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 = 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) case n[0].sym.magic: of mOr: result.map = ctx.union(mapL, mapR) of mAnd: result.map = checkCondition(n[1], ctx, map, false, false) result.map = checkCondition(n[2], ctx, result.map, false, false) of mEqRef: if n[2].kind == nkIntLit: if $n[2] == "true": result.map = checkCondition(n[1], ctx, map, false, false) elif $n[2] == "false": result.map = checkCondition(n[1], ctx, map, true, false) elif n[1].kind == nkIntLit: if $n[1] == "true": result.map = checkCondition(n[2], ctx, map, false, false) elif $n[1] == "false": result.map = checkCondition(n[2], ctx, map, true, false) if result.map.isNil: result.map = map else: result.map = map else: result.map = map result.nilability = Safe proc checkIsNil(n, ctx, map; isElse: bool = false): Check = ## check isNil calls ## update the map depending on if it is not isNil or isNil result = Check(map: newNilMap(map)) let value = n[1] result.map.store(ctx, ctx.index(n[1]), if not isElse: Nil else: Safe, TArg, n.info, n) proc infix(ctx: NilCheckerContext, l: PNode, r: PNode, magic: TMagic): PNode = var name = case magic: of mEqRef: "==" of mAnd: "and" of mOr: "or" else: "" var cache = newIdentCache() var op = newSym(skVar, cache.getIdent(name), ctx.idgen, nil, r.info) op.magic = magic result = nkInfix.newTree( newSymNode(op, r.info), l, r) result.typ = newType(tyBool, ctx.idgen, nil) proc prefixNot(ctx: NilCheckerContext, node: PNode): PNode = var cache = newIdentCache() var op = newSym(skVar, cache.getIdent("not"), ctx.idgen, nil, node.info) op.magic = mNot result = nkPrefix.newTree( newSymNode(op, node.info), node) result.typ = newType(tyBool, ctx.idgen, nil) proc infixEq(ctx: NilCheckerContext, l: PNode, r: PNode): PNode = infix(ctx, l, r, mEqRef) proc infixOr(ctx: NilCheckerContext, l: PNode, r: PNode): PNode = infix(ctx, l, r, mOr) proc checkCase(n, ctx, map): Check = # case a: # of b: c # of b2: c2 # is like # if a == b: # c # elif a == b2: # c2 # also a == true is a , a == false is not a let base = n[0] result = Check(map: map.copyMap()) result.nilability = Safe var a: PNode = nil for child in n: case child.kind: of nkOfBranch: if child.len < 2: # echo "case with of with < 2 ", n continue # TODO why does this happen let branchBase = child[0] # TODO a, b or a, b..c etc let code = child[^1] let test = infixEq(ctx, base, branchBase) if a.isNil: a = test else: a = infixOr(ctx, a, test) let conditionMap = checkCondition(test, ctx, map.copyMap(), false, false) let newCheck = checkBranch(code, ctx, conditionMap) result.map = ctx.union(result.map, newCheck.map) result.nilability = union(result.nilability, newCheck.nilability) of nkElifBranch: discard "TODO: maybe adapt to be similar to checkIf" of nkElse: let mapElse = checkCondition(prefixNot(ctx, a), ctx, map.copyMap(), false, false) let newCheck = checkBranch(child[0], ctx, mapElse) result.map = ctx.union(result.map, newCheck.map) result.nilability = union(result.nilability, newCheck.nilability) else: discard # notes # try: # a # b # except: # c # finally: # d # # if a doesnt raise, this is not an exit point: # so find what raises and update the map with that # (a, b); c; d # if nothing raises, except shouldn't happen # .. might be a false positive tho, if canRaise is not conservative? # so don't visit it # # nested nodes can raise as well: I hope nim returns canRaise for # their parents # # a lot of stuff can raise proc checkTry(n, ctx, map): Check = var newMap = map.copyMap() var currentMap = map # we don't analyze except if nothing canRaise in try var canRaise = false var hasFinally = false # var tryNodes: seq[PNode] # if n[0].kind == nkStmtList: # tryNodes = toSeq(n[0]) # else: # tryNodes = @[n[0]] # for i, child in tryNodes: # let (childNilability, childMap) = check(child, conf, currentMap) # echo childMap # currentMap = childMap # # TODO what about nested # if child.canRaise: # newMap = union(newMap, childMap) # canRaise = true # else: # newMap = childMap let tryCheck = check(n[0], ctx, currentMap) newMap = ctx.union(currentMap, tryCheck.map) canRaise = n[0].canRaise var afterTryMap = newMap for a, branch in n: if a > 0: case branch.kind: of nkFinally: newMap = ctx.union(afterTryMap, newMap) let childCheck = check(branch[0], ctx, newMap) newMap = ctx.union(newMap, childCheck.map) hasFinally = true of nkExceptBranch: if canRaise: let childCheck = check(branch[^1], ctx, newMap) newMap = ctx.union(newMap, childCheck.map) else: discard if not hasFinally: # we might have not hit the except branches newMap = ctx.union(afterTryMap, newMap) result = Check(nilability: Safe, map: newMap) proc hasUnstructuredControlFlowJump(n: PNode): bool = ## if the node contains a direct stop ## as a continue/break/raise/return: then it means ## we should reverse some of the map in the code after the condition ## similar to else # echo "n ", n, " ", n.kind case n.kind: of nkStmtList: for child in n: if hasUnstructuredControlFlowJump(child): return true of nkReturnStmt, nkBreakStmt, nkContinueStmt, nkRaiseStmt: return true of nkIfStmt, nkIfExpr, nkElifExpr, nkElse: return false else: discard return false proc reverse(value: Nilability): Nilability = case value: of Nil: Safe of MaybeNil: MaybeNil of Safe: Nil of Parent: Parent of Unreachable: Unreachable proc reverse(kind: TransitionKind): TransitionKind = case kind: of TNil: TSafe of TSafe: TNil of TPotentialAlias: TPotentialAlias else: kind # raise newException(ValueError, "expected TNil or TSafe") proc reverseDirect(map: NilMap): NilMap = # we create a new layer # reverse the values only in this layer: # because conditions should've stored their changes there # b: Safe (not b.isNil) # b: Parent Parent # b: Nil (b.isNil) # layer block # [ Parent ] [ Parent ] # if -> if state # layer -> reverse # older older0 new # older new # [ b Nil ] [ Parent ] # elif # [ b Nil, c Nil] [ Parent ] # # if b.isNil: # # [ b Safe] # c = A() # Safe # elif not b.isNil: # # [ b Safe ] + [b Nil] MaybeNil Unreachable # # Unreachable defer can't deref b, it is unreachable # discard # else: # b # if # if: we just pass the map with a new layer for its block # elif: we just pass the original map but with a new layer is the reverse of the previous popped layer (?) # elif: # else: we just pass the original map but with a new layer which is initialized as the reverse of the # top layer of else # else: # # [ b MaybeNil ] [b Parent] [b Parent] [b Safe] [b Nil] [] # Safe # c == 1 # b Parent # c == 2 # b Parent # not b.isNil # b Safe # c == 3 # b Nil # (else) # b Nil result = map.copyMap() for index, value in result.expressions: result.expressions[index] = reverse(value) if result.history[index].len > 0: result.history[index][^1].kind = reverse(result.history[index][^1].kind) result.history[index][^1].nilability = result.expressions[index] proc checkCondition(n, ctx, map; reverse: bool, base: bool): NilMap = ## check conditions : used for if, some infix operators ## isNil(a) ## it returns a new map: you need to reverse all the direct elements for else # echo "condition ", n, " ", n.kind if n.kind == nkCall: result = newNilMap(map) for element in n: if element.kind == nkHiddenDeref and n[0].kind == nkSym and n[0].sym.magic == mIsNil: result = check(element[0], ctx, result).map else: result = check(element, ctx, result).map if n[0].kind == nkSym and n[0].sym.magic == mIsNil: # isNil(arg) var arg = n[1] while arg.kind == nkHiddenDeref: arg = arg[0] if arg.kind in {nkSym, nkDotExpr} or isConstBracket(arg): let a = ctx.index(arg) result.store(ctx, a, if not reverse: Nil else: Safe, if not reverse: TNil else: TSafe, n.info, arg) else: discard else: discard elif n.kind == nkPrefix and n[0].kind == nkSym and n[0].sym.magic == mNot: result = checkCondition(n[1], ctx, map, not reverse, false) elif n.kind == nkInfix: result = newNilMap(map) result = checkInfix(n, ctx, result).map else: result = check(n, ctx, map).map result = newNilMap(map) assert not result.isNil assert not result.parent.isNil proc checkResult(n, ctx, map) = let resultNilability = map[resultExprIndex] case resultNilability: of Nil: message(ctx.config, n.info, warnStrictNotNil, "return value is nil") of MaybeNil: message(ctx.config, n.info, warnStrictNotNil, "return value might be nil") of Unreachable: message(ctx.config, n.info, warnStrictNotNil, "return value is unreachable") of Safe, Parent: discard proc checkBranch(n: PNode, ctx: NilCheckerContext, map: NilMap): Check = result = check(n, ctx, map) # Faith! proc check(n: PNode, ctx: NilCheckerContext, map: NilMap): Check = assert not map.isNil # echo "check n ", n, " ", n.kind # echo "map ", namedMapDebugInfo(ctx, map) case n.kind: of nkSym: result = Check(nilability: map[ctx.index(n)], map: map) of nkCallKinds: if n.sons[0].kind == nkSym: let callSym = n.sons[0].sym case callSym.magic: of mAnd, mOr: result = checkInfix(n, ctx, map) of mIsNil: result = checkIsNil(n, ctx, map) else: result = checkCall(n, ctx, map) else: result = checkCall(n, ctx, map) of nkHiddenStdConv, nkHiddenSubConv, nkConv, nkExprColonExpr, nkExprEqExpr, nkCast: result = check(n.sons[1], ctx, map) of nkStmtList, nkStmtListExpr, nkChckRangeF, nkChckRange64, nkChckRange, nkBracket, nkCurly, nkPar, nkTupleConstr, nkClosure, nkObjConstr, nkElse: result = Check(map: map) if n.kind in {nkObjConstr, nkTupleConstr}: # TODO deeper nested elements? # A(field: B()) # # field: Safe -> var elements: seq[(PNode, Nilability)] = @[] for i, child in n: result = check(child, ctx, result.map) if i > 0: if child.kind == nkExprColonExpr: elements.add((child[0], result.nilability)) result.elements = elements result.nilability = Safe else: for child in n: result = check(child, ctx, result.map) of nkDotExpr: result = checkDotExpr(n, ctx, map) of nkDerefExpr, nkHiddenDeref: result = checkDeref(n, ctx, map) of nkAddr, nkHiddenAddr: result = check(n.sons[0], ctx, map) of nkIfStmt, nkIfExpr: result = checkIf(n, ctx, map) of nkAsgn, nkFastAsgn, nkSinkAsgn: result = checkAsgn(n[0], n[1], ctx, map) of nkVarSection, nkLetSection: result = Check(map: map) for child in n: result = checkAsgn(child[0].skipPragmaExpr, child[2], ctx, result.map) of nkForStmt: result = checkFor(n, ctx, map) of nkCaseStmt: result = checkCase(n, ctx, map) of nkReturnStmt: result = checkReturn(n, ctx, map) of nkBracketExpr: result = checkBracketExpr(n, ctx, map) of nkTryStmt: result = checkTry(n, ctx, map) of nkWhileStmt: result = checkWhile(n, ctx, map) of nkNone..pred(nkSym), succ(nkSym)..nkNilLit, nkTypeSection, nkProcDef, nkConverterDef, nkMethodDef, nkIteratorDef, nkMacroDef, nkTemplateDef, nkLambda, nkDo, nkFuncDef, nkConstSection, nkConstDef, nkIncludeStmt, nkImportStmt, nkExportStmt, nkPragma, nkCommentStmt, nkBreakState, nkTypeOfExpr, nkMixinStmt, nkBindStmt: discard "don't follow this : same as varpartitions" result = Check(nilability: Nil, map: map) else: var elementMap = map.copyMap() var elementCheck = Check(map: elementMap) for element in n: elementCheck = check(element, ctx, elementCheck.map) result = Check(nilability: Nil, map: elementCheck.map) proc typeNilability(typ: PType): Nilability = assert not typ.isNil # echo "typeNilability ", $typ.flags, " ", $typ.kind result = if tfNotNil in typ.flags: Safe elif typ.kind in {tyRef, tyCstring, tyPtr, tyPointer}: # # tyVar ? tyVarargs ? tySink ? tyLent ? # TODO spec? tests? MaybeNil else: Safe # echo " result ", result proc preVisitNode(ctx: NilCheckerContext, node: PNode, conf: ConfigRef) = # echo "visit node ", node if node.kind in {nkSym, nkDotExpr} or isConstBracket(node): let nodeSymbol = symbol(node) if not ctx.symbolIndices.hasKey(nodeSymbol): ctx.symbolIndices[nodeSymbol] = ctx.expressions.len ctx.expressions.add(node) if node.kind in {nkDotExpr, nkBracketExpr}: if node.kind == nkDotExpr and (not node.typ.isNil and node.typ.kind == tyRef and tfNotNil notin node.typ.flags) or node.kind == nkBracketExpr: let index = ctx.symbolIndices[nodeSymbol] var baseIndex = noExprIndex # deref usually? # ok, we hit another case var base = if node[0].kind notin {nkSym, nkIdent}: node[0][0] else: node[0] if base.kind != nkIdent: let baseSymbol = symbol(base) if not ctx.symbolIndices.hasKey(baseSymbol): baseIndex = ctx.expressions.len # next visit should add it else: baseIndex = ctx.symbolIndices[baseSymbol] if ctx.dependants.len <= baseIndex: ctx.dependants.setLen(baseIndex + 1.ExprIndex) ctx.dependants[baseIndex].incl(index.int) case node.kind: of nkSym, nkEmpty, nkNilLit, nkType, nkIdent, nkCharLit .. nkUInt64Lit, nkFloatLit .. nkFloat64Lit, nkStrLit .. nkTripleStrLit: discard of nkDotExpr: # visit only the base ctx.preVisitNode(node[0], conf) else: for element in node: ctx.preVisitNode(element, conf) 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 = initIntSet() # set[ExprIndex] ctx.dependants = SeqOfDistinct[ExprIndex, IntSet](@[emptySet]) for i, arg in s.typ.n.sons: if i > 0: if arg.kind != nkSym: continue let argSymbol = symbol(arg) if not ctx.symbolIndices.hasKey(argSymbol): ctx.symbolIndices[argSymbol] = ctx.expressions.len ctx.expressions.add(arg) ctx.preVisitNode(body, conf) if ctx.dependants.len < ctx.expressions.len: ctx.dependants.setLen(ctx.expressions.len) # echo ctx.symbolIndices # echo ctx.expressions # echo ctx.dependants proc checkNil*(s: PSym; body: PNode; conf: ConfigRef, idgen: IdGenerator) = let line = s.ast.info.line let fileIndex = s.ast.info.fileIndex.int var filename = conf.m.fileInfos[fileIndex].fullPath.string var context = NilCheckerContext(config: conf, idgen: idgen) context.preVisit(s, body, conf) var map = newNilMap(nil, context.symbolIndices.len) for i, child in s.typ.n.sons: if i > 0: if child.kind != nkSym: continue map.store(context, context.index(child), typeNilability(child.typ), TArg, child.info, child) map.store(context, resultExprIndex, if not s.typ.returnType.isNil and s.typ.returnType.kind == tyRef: Nil else: Safe, TResult, s.ast.info) # echo "checking ", s.name.s, " ", filename let res = check(body, context, map) var canCheck = resultExprIndex in res.map.history.low .. res.map.history.high if res.nilability == Safe and canCheck and res.map.history[resultExprIndex].len <= 1: res.map.store(context, resultExprIndex, Safe, TAssign, s.ast.info) else: if res.nilability == Safe: res.map.store(context, resultExprIndex, Safe, TAssign, s.ast.info) # TODO check for nilability result # (ANotNil, BNotNil) : # do we check on asgn nilability at all? if not s.typ.returnType.isNil and s.typ.returnType.kind == tyRef and tfNotNil in s.typ.returnType.flags: checkResult(s.ast, context, res.map)