ARC, finalizer, allow rebinding the same function multiple times

[StefanSalewski]

https://forum.nim-lang.org/t/5734#35917

I would assume that it should be possible, if not we may have to use

https://forum.nim-lang.org/t/5786

but that would call for much rewriting of course.

$ nim c --gc:arc t0.nim 
/home/stefan/.nimble/pkgs/gintro-0.6.1/gintro/glib.nim(969, 6) Error: cannot bind another 'gBoxedFreeGBytes' to: Bytes:ObjectType; previous declaration was here: /home/stefan/.nimble/pkgs/gintro-0.6.1/gintro/glib.nim(897, 6)

There is only one single

$ grep "proc gBoxedFreeGBytes" ~/.nimble/pkgs/gintro-0.6.1/gintro/*
/home/stefan/.nimble/pkgs/gintro-0.6.1/gintro/glib.nim:proc gBoxedFreeGBytes*(self: Bytes) =

But there is

proc newBytesTake*(data: seq[uint8] | string): Bytes =
  let size = uint64(data.len)
  new(result, gBoxedFreeGBytes)
  result.impl = g_bytes_new_take(unsafeaddr(data[0]), size)

proc newBytesFromBytes*(self: Bytes; offset: uint64; length: uint64): Bytes =
  new(result, gBoxedFreeGBytes)
  result.impl = g_bytes_new_from_bytes(cast[ptr Bytes00](self.impl), offset, length)

proc g_bytes_ref(self: ptr Bytes00): ptr Bytes00 {.
    importc, libprag.}

proc `ref`*(self: Bytes): Bytes =
  new(result, gBoxedFreeGBytes)
  result.impl = g_bytes_ref(cast[ptr Bytes00](self.impl))

proc newBytes*(data: seq[uint8] | string): Bytes =
  let size = uint64(data.len)
  new(result, gBoxedFreeGBytes)
  result.impl = g_bytes_new(unsafeaddr(data[0]), size)

proc initBytes*[T](result: var T; data: seq[uint8] | string) =
  let size = uint64(data.len)
  assert(result is Bytes)
  new(result, gBoxedFreeGBytes)
  result.impl = g_bytes_new(unsafeaddr(data[0]), size)

But yes, we may be able to rewrite that -- for only one newBytes proc.

[Araq]

It's a valid bug, hopefully not too hard to fix.

[StefanSalewski]

Great. And it correctly detects a bug in my glib.nim now:

$ nim c --gc:arc t0.nim 
/home/stefan/.nimble/pkgs/gintro-0.6.1/gintro/glib.nim(7537, 6) Error: cannot bind another '=destroy' to: Variant:ObjectType; previous declaration was constructed here implicitly: /home/stefan/.nimble/pkgs/gintro-0.6.1/gintro/glib.nim(7285, 6)

Will try to investigate and fix that soon.

But I wonder why compiling with default gc does not yet detect that error, as from my memory also default gc can bind only to one single finalizer. But well, no problem for me.

[StefanSalewski]

No, was not a real bug in gintro, but intended. A few functions just return objects owned by gtk that should not be freed, while other functions return instances of same class that has to be freed by user. So it was intended that new() was used with and without finalizer for same object type. But I guess it has not worked really for default gc., I guess last call just replaced finalizer.

[Araq]

Finalizers in the old GCs are indeed attached to a type, not to an instance. So once you called var x: T; new(x, finalize) all allocations of T are affected.

[StefanSalewski]

Yes I know, just reread docs for new(). And I assume that it is the same for ARC now?

In glib.nim I currently have

proc newVariantBoolean*(value: bool): Variant =
  new(result)
  result.impl = g_variant_new_boolean(gboolean(value))

and

proc byteswap*(self: Variant): Variant =
  new(result, unref)
  result.impl = g_variant_byteswap(cast[ptr Variant00](self.impl))

for example which gives for ARC a fine error messages, but compiles fine for default GC. I think this should not really compile for default GC, or at least give a warning?

[Araq]

I think this should not really compile for default GC, or at least give a warning?

Well it's undetected either way. No warnings produced for new(x).

[disruptek]

Wait, so how do we port new(result, conan) such that it works outside arc?