Unless I'm mistaken, this page:
http://dlang.org/garbage.html
states that it's safe to use a union to share storage with a pointer, e.g.
union U { void* ptr; int value }
But that wouldn't be safe if the GC ever moved objects. Should the page
be tweaked? Especially as further down on that page, it says that a
moving garbage collector can be implemented if one follows the rules.

Unless I'm mistaken, this page:
http://dlang.org/garbage.html
states that it's safe to use a union to share storage with a pointer, e.g.
union U { void* ptr; int value }
But that wouldn't be safe if the GC ever moved objects. Should the page
be tweaked? Especially as further down on that page, it says that a
moving garbage collector can be implemented if one follows the rules.

Actually I suppose it's possible for any object affected by that union
to be pinned. Is that the intention?

Unless I'm mistaken, this page:
http://dlang.org/garbage.html
states that it's safe to use a union to share storage with a
pointer, e.g.
union U { void* ptr; int value }
But that wouldn't be safe if the GC ever moved objects. Should
the page
be tweaked? Especially as further down on that page, it says
that a
moving garbage collector can be implemented if one follows the
rules.

Actually I suppose it's possible for any object affected by
that union to be pinned. Is that the intention?

As I understand it, there will always be uncertain references,
such as those found on the stack (esp. stack of C functions) and
data segment. Such uncertain references will pin objects they
point at, however ideally this would only apply to a small
percentage of heap objects. A moving GC in D would only move
those objects for which it can be certain that it knows how to
safely update all existing references to the object.