Compiler: don't precompute sizeof on abstract structs and modules

[asterite]

Fixes #7741

And a few other fixes/improvements too.

I'm marking it as a breaking change too because instance_sizeof could be incorrectly invoked with non-class stuff (like structs) and so this will make compiling (but incorrect) code to stop compiling... but I think it's fine.

[asterite]

Some explanation: at some point we made sizeof be computed, if possible, at the semantic phase so that it can be used for generic type arguments, like StaticArray(UInt8, sizeof(Int32)). That works fine, but when the type given to sizeof is an abstract thing like a struct or a module, and there are generic subtypes, the final size (which is the size of the union of all actual instantiations in the program) can only be known at the end of compilation. This is what this PR fixes.

[bcardiff]

Can't this be moved upwards together with the check of type.is_a?(GenericType)? I thought the notion of an instantiable type was already defined somewhere.

[asterite]

Here in MainVisitor we compute it if we can. Later in CleanupTransformer we check that it's only a class. So, doing sizeof an abstract struct or module can be done and works, just not eagerly.

To be honest, now I'm not convinced that sizeof should work eagerly at all. I did that so one can do, for example, StaticArray(Int32, sizeof(Int32)), but that's a pretty contrived example. But for now I'm just fixing broken things, not changing the semantics of the language or introducing breaking changes. But eventually we can define the semantics we want for this and fix it.

And no, unfortunately there's no type.can_be_instantiated? method.

[Blacksmoke16]

Can confirm this fixed my issue. Thanks again.