Implementing this unfortunately isn't trivial because the macro method implementation is not aware of the current compiler stage. A central point such as the Program instance isn't reachable from there.

As an alternative, we could use a flag on each type that tells whether (its) instance variables have been initialized. I'd like to avoid increasing the size by adding another instance variable, though.

Looking at the layout of InstanceVarContainer types, I noticed that @instance_vars is lazily initialized. Maybe we could use its nil state as a signal that instance variables have not yet been initialized?
In fact, almost all types have @instance_vars initialized after the top-level semantic has run. In some cases the collection is empty, but still initialized. I presume that's because somewhere we're calling an accessor to check whether an instance variable exist (Type#lookup_instance_var or something like that) and the accessor initializes it as empty.
The only exceptions are module types (NonGenericModuleType and GenericModuleType): When the module itself doesn't declare any instance variables, @instance_vars is still uninitialized.

I think it could work that we use nil as a signal if we replace all nil instances with an empty collection after top -level semantic has run. We just have to force initializing all @instance_vars to a non-nil value at this point.
@instance_vars should never be mutated again afterwards, so we can even use a singleton for empty values to avoid allocations.