Assignment overloading: infinite recursion even with system.=

[mratsim]

The following will lead to infinite Hello World being printed

type
  Foo = object
  Bar = object
    foo: Foo


proc `=`*(dest: var Foo, src: Foo) =
  echo "hello World!"
  system.`=`(dest, src)

proc initFoo(): Foo =
  discard

proc initBar(foo: Foo): Bar =
  result.foo = foo

let x = initFoo()

let y = initBar(x)

Having local variables instead works (cc @Clyybber)

type
  Foo = object
  Bar = object
    foo: Foo


proc `=`*(dest: var Foo, src: Foo) =
  echo "hello World!"
  system.`=`(dest, src)

proc initFoo(): Foo =
  discard

proc initBar(foo: sink Foo): Bar =
  echo "hi"
  result.foo = foo
  echo "ho"

proc main =
  let x = initFoo()
  echo "ha"
  let y = initBar(x)

main()

[mratsim]

And a slightly different case, adding a =sink recreates the problem even with a main proc

type
  Foo = object
  Bar = object
    foo: Foo

proc `=sink`*(dst: var Foo, src: Foo) {.inline.}

proc `=`*(dest: var Foo, src: Foo) =
  echo "hello World!"
  system.`=`(dest, src)

proc `=sink`*(dst: var Foo, src: Foo) {.inline.} =
  system.`=sink`(dst, src)

proc initFoo*(): Foo =
  discard

proc initBar*(foo: sink Foo): Bar =
  echo "hi"
  result.foo = foo
  echo "ho"

proc main =
  let x = initFoo()
  echo "ha"
  let y = initBar(x)

main()

The forward declaration is a workaround for #13025

[mratsim]

Ah it was not local variables but the sink annotation that solved the issue here, this recurses infinitely:

type
  Foo = object
  Bar = object
    foo: Foo

proc `=`*(dest: var Foo, src: Foo) =
  echo "hello World!"
  system.`=`(dest, src)

proc initFoo*(): Foo =
  discard

proc initBar*(foo: Foo): Bar =
  echo "hi"
  result.foo = foo
  echo "ho"

proc main =
  let x = initFoo()
  echo "ha"
  let y = initBar(x)

main()

[cooldome]

Hi @mratsim,
Could you please describe what you are trying to achieve?
The = in system is just a stub that will get resolved to a type specific assignment later on. It is not any different from a = b. It is possible to fix forced forward declaration for destructors, but infinite recursion is here to stay IMO.

Possibly you wanted:

`=`(ParentType(a), ParentType(b))

[mratsim]

It can be closed as won't fix then. However, I expect others will encounter this issue as in the past this was the recommended pattern to overload = (when it worked), so an example would be nice in the destructors documentation.

I was trying to do custom atomic ref counting. So after discussing with @Araq what I wanted to do is:

type
  Foo = object
    p: FooImpl
  FooImp = ptr object

proc `=`(dst: var Foo, src: Foo) =
  # refcounting goes here
  system.`=`(dst.p, src.p) # Notice that I don't copy the dst/src but the fields to avoid recursion

[shirleyquirk]

only the =sink version recurs on devel (1.1.1)

[mratsim]

(deleting duplicate comment)