iterator declaration zeros variable on ARC/ORC

[levovix0]

Example

type Node = ref object
  kind: Node

var n1 = Node()
var n2 = Node()

n2.kind = n1

iterator iter(x: Node): Node =
  discard

echo cast[int](n1)

Current Output

0

Expected Output

some non-zero address

Additional Information

without --gc:orc or --gc:arc works fine
also if add echo cast[int](n1) before iterator declaration, works fine

$ nim -v
Nim Compiler Version 1.7.1 [Linux: amd64]
Compiled at 2022-05-14
Copyright (c) 2006-2022 by Andreas Rumpf

git hash: 19001c070bbe7645ff45fcbd66ab221235715302
active boot switches: -d:release

on 1.6.6 this bug also exists

[ringabout]

Or

type Node = ref object
  kind: Node

var n1 = Node()
var n2 = Node()
n2.kind = n1

proc foo =
  echo cast[int](n1)

foo()

[ringabout]

It looks like dfa analysis cannot pass the scope boundry. Nim compiler thinks n2.kind = n1 is lastRead for n1 and sinks it. I'm still looking at dfa and injectdestructors.

[ringabout]

Yeah, the program splits into three parts.

var
  n1
  n2
type
  Node = ref object
    kind: Node

n1 = Node()
n2 = Node()
`=sink`(n2.kind, n1)
wasMoved(n1)

iterator iter(x: Node): Node =
  discard

var :tmpD_452984865
try:
  echo [
    :tmpD_452984865 = cast[int](n1)
    :tmpD_452984865]
finally:
  `=destroy`(:tmpD_452984865)

[ringabout]

It seems to caused by how the parser parses the top level statement: read everything until the next proc declaration etc. The top level statements splits into different parts. Dfa can only analyse them seperately. So dfa can only get partial infos regarding symbols.

[ringabout]

It breaks zero-functional tests.

import zero_functional, options, lists


type
  SimpleIter = ref object
    items: seq[int]

proc initSimpleIter(): SimpleIter =
  SimpleIter(items: @[1, 2, 3])

proc len(si: SimpleIter): int =
  si.items.len()

iterator items(si: SimpleIter): int =
  for i in 0..<len(si.items):
    yield(si.items[i])

let si = initSimpleIter()

var d = si --> to(list)
d --> foreach(it = it * 2)
echo d --> to(seq)
let e: DoublyLinkedList[int] = d
discard(e)
echo d --> to(seq)
doAssert(d --> to(seq) == @[2, 4, 6])

--> EXPANDS TO

proc (): auto =
  {.push, hint[XDeclaredButNotUsed]: false.}
  proc `__iterType__`(): auto =
    var __itList__ = d.head
    var idx = 0
    while (
      not (__itList__ == nil)):
      let __it0 = __itList__.value
      let _itListNext = __itList__.next
      let __it1 = __it0
      result = (__it0, __it1)

  {.pop.}
  var res`gensym87: seq[type(__iterType__()[1])]
  result = zfInit(res`gensym87)
  var __itList__ = d.head
  var idx = 0
  while (
    not (__itList__ == nil)):
    let __it0 = __itList__.value
    let _itListNext = __itList__.next
    let __it1 = __it0
    zfAddItem(result, idx, __it1)
    __itList__ = _itListNext
    idx += 1()