jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Tables, use sink val arguments more actively (#15625)

Browse source
This commit is contained in:
cooldome 2020-10-19 13:13:26 +01:00 • committed by GitHub
commit 04f8fcfbd0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 30 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

5
compiler/sempass2.nim
View file

@ -514,8 +514,9 @@ proc notNilCheck(tracked: PEffects, n: PNode, paramType: PType) =
#elif n.kind in nkSymChoices: #elif n.kind in nkSymChoices:
# echo "came here" # echo "came here"
let paramType = paramType.skipTypesOrNil(abstractInst) let paramType = paramType.skipTypesOrNil(abstractInst)
if paramType != nil and tfNotNil in paramType.flags and if paramType != nil and tfNotNil in paramType.flags and n.typ != nil:
n.typ != nil and tfNotNil notin n.typ.flags: let ntyp = n.typ.skipTypesOrNil({tyVar, tyLent, tySink})
if ntyp != nil and tfNotNil notin ntyp.flags:
if isAddrNode(n): if isAddrNode(n):
# addr(x[]) can't be proven, but addr(x) can: # addr(x[]) can't be proven, but addr(x) can:
if not containsNode(n, {nkDerefExpr, nkHiddenDeref}): return if not containsNode(n, {nkDerefExpr, nkHiddenDeref}): return

2
lib/pure/collections/tableimpl.nim
View file

@ -27,7 +27,7 @@ proc rawGetDeep[X, A](t: X, key: A, hc: var Hash): int {.inline.} =
rawGetDeepImpl() rawGetDeepImpl()
proc rawInsert[X, A, B](t: var X, data: var KeyValuePairSeq[A, B], proc rawInsert[X, A, B](t: var X, data: var KeyValuePairSeq[A, B],
key: A, val: B, hc: Hash, h: Hash) = key: A, val: sink B, hc: Hash, h: Hash) =
rawInsertImpl() rawInsertImpl()
template checkIfInitialized() = template checkIfInitialized() =

18
lib/pure/collections/tables.nim
View file

@ -300,7 +300,7 @@ proc initTable*[A, B](initialSize = defaultInitialSize): Table[A, B] =
b = initTable[char, seq[int]]() b = initTable[char, seq[int]]()
initImpl(result, initialSize) initImpl(result, initialSize)
proc `[]=`*[A, B](t: var Table[A, B], key: A, val: B) = proc `[]=`*[A, B](t: var Table[A, B], key: A, val: sink B) =
## Inserts a ``(key, value)`` pair into ``t``. ## Inserts a ``(key, value)`` pair into ``t``.
## ##
## See also: ## See also:
@ -484,7 +484,7 @@ proc len*[A, B](t: Table[A, B]): int =
result = t.counter result = t.counter
proc add*[A, B](t: var Table[A, B], key: A, val: B) {.deprecated: proc add*[A, B](t: var Table[A, B], key: A, val: sink B) {.deprecated:
"Deprecated since v1.4; it was more confusing than useful, use `[]=`".} = "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists. ## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists.
## ##
@ -839,7 +839,7 @@ proc `[]`*[A, B](t: TableRef[A, B], key: A): var B =
result = t[][key] result = t[][key]
proc `[]=`*[A, B](t: TableRef[A, B], key: A, val: B) = proc `[]=`*[A, B](t: TableRef[A, B], key: A, val: sink B) =
## Inserts a ``(key, value)`` pair into ``t``. ## Inserts a ``(key, value)`` pair into ``t``.
## ##
## See also: ## See also:
@ -968,7 +968,7 @@ proc len*[A, B](t: TableRef[A, B]): int =
result = t.counter result = t.counter
proc add*[A, B](t: TableRef[A, B], key: A, val: B) {.deprecated: proc add*[A, B](t: TableRef[A, B], key: A, val: sink B) {.deprecated:
"Deprecated since v1.4; it was more confusing than useful, use `[]=`".} = "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists. ## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists.
## ##
@ -1217,7 +1217,7 @@ proc rawGet[A, B](t: OrderedTable[A, B], key: A, hc: var Hash): int =
proc rawInsert[A, B](t: var OrderedTable[A, B], proc rawInsert[A, B](t: var OrderedTable[A, B],
data: var OrderedKeyValuePairSeq[A, B], data: var OrderedKeyValuePairSeq[A, B],
key: A, val: B, hc: Hash, h: Hash) = key: A, val: sink B, hc: Hash, h: Hash) =
rawInsertImpl() rawInsertImpl()
data[h].next = -1 data[h].next = -1
if t.first < 0: t.first = h if t.first < 0: t.first = h
@ -1268,7 +1268,7 @@ proc initOrderedTable*[A, B](initialSize = defaultInitialSize): OrderedTable[A,
b = initOrderedTable[char, seq[int]]() b = initOrderedTable[char, seq[int]]()
initImpl(result, initialSize) initImpl(result, initialSize)
proc `[]=`*[A, B](t: var OrderedTable[A, B], key: A, val: B) = proc `[]=`*[A, B](t: var OrderedTable[A, B], key: A, val: sink B) =
## Inserts a ``(key, value)`` pair into ``t``. ## Inserts a ``(key, value)`` pair into ``t``.
## ##
## See also: ## See also:
@ -1455,7 +1455,7 @@ proc len*[A, B](t: OrderedTable[A, B]): int {.inline.} =
result = t.counter result = t.counter
proc add*[A, B](t: var OrderedTable[A, B], key: A, val: B) {.deprecated: proc add*[A, B](t: var OrderedTable[A, B], key: A, val: sink B) {.deprecated:
"Deprecated since v1.4; it was more confusing than useful, use `[]=`".} = "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists. ## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists.
## ##
@ -1810,7 +1810,7 @@ proc `[]`*[A, B](t: OrderedTableRef[A, B], key: A): var B =
echo a['z'] echo a['z']
result = t[][key] result = t[][key]
proc `[]=`*[A, B](t: OrderedTableRef[A, B], key: A, val: B) = proc `[]=`*[A, B](t: OrderedTableRef[A, B], key: A, val: sink B) =
## Inserts a ``(key, value)`` pair into ``t``. ## Inserts a ``(key, value)`` pair into ``t``.
## ##
## See also: ## See also:
@ -1939,7 +1939,7 @@ proc len*[A, B](t: OrderedTableRef[A, B]): int {.inline.} =
result = t.counter result = t.counter
proc add*[A, B](t: OrderedTableRef[A, B], key: A, val: B) {.deprecated: proc add*[A, B](t: OrderedTableRef[A, B], key: A, val: sink B) {.deprecated:
"Deprecated since v1.4; it was more confusing than useful, use `[]=`".} = "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists. ## Puts a new ``(key, value)`` pair into ``t`` even if ``t[key]`` already exists.
## ##