Add an aliases for mutable types in CIR

[bcardosolopes]

          Unfortunately, mutable types do not support aliases yet, but there is a fix for this in review: https://github.com/llvm/llvm-project/pull/66663.

At some point, we will likely be able to use aliases on everything, so I suggest that, for now, we leave only the structs using full types and everything else using aliases.

Originally posted by @sitio-couto in #303 (comment)

[smeenai]

The mentioned fix looks like it's stalled, unfortunately. I wasn't aware of this issue before but I ran into the same problem and created llvm/llvm-project#110346 as a much simpler fix. It doesn't allow recursive aliases to reference themselves, but it enables all other aliases to be printed within structs. E.g. for C++ code like:

struct T;
struct S { int i; S *s; T *t; };
struct T { int j; S *s; T *t; };
T t;

You would previously get:

!ty_S = !cir.struct<struct "S" {!cir.int<s, 32>, !cir.ptr<!cir.struct<struct "S">>, !cir.ptr<!cir.struct<struct "T" {!cir.int<s, 32>, !cir.ptr<!cir.struct<struct "S">>, !cir.ptr<!cir.struct<struct "T">>} #cir.record.decl.ast>>} #cir.record.decl.ast>
!ty_T = !cir.struct<struct "T" {!cir.int<s, 32>, !cir.ptr<!cir.struct<struct "S" {!cir.int<s, 32>, !cir.ptr<!cir.struct<struct "S">>, !cir.ptr<!cir.struct<struct "T">>} #cir.record.decl.ast>>, !cir.ptr<!cir.struct<struct "T">>} #cir.record.decl.ast>

After my change, you get:

!ty_S = !cir.struct<struct "S" {!s32i, !cir.ptr<!cir.struct<struct "S">>, !cir.ptr<!cir.struct<struct "T" {!s32i, !cir.ptr<!cir.struct<struct "S">>, !cir.ptr<!cir.struct<struct "T">>} #cir.record.decl.ast>>} #cir.record.decl.ast>
!ty_T = !cir.struct<struct "T" {!s32i, !cir.ptr<!ty_S>, !cir.ptr<!cir.struct<struct "T">>} #cir.record.decl.ast>

I think that's already a decent improvement. One further improvement here would be to have the definition of !ty_S reference the incomplete version of T instead of the complete one; I'll see how tricky that is.

[smeenai]

I did a ClangIR rebase this week which included my MLIR change, so we now get nicer printing for structs. E.g. for

struct S { int i; };
struct T : S { int j; };

you get

!ty_S = !cir.struct<struct "S" {!s32i} #cir.record.decl.ast>
!ty_T = !cir.struct<struct "T" {!ty_S, !s32i} #cir.record.decl.ast>

The one remaining problem is mutually recursive structs, as mentioned above. For

struct T;
struct S { T *t; };
struct T { S *s; };

you get

!ty_S = !cir.struct<struct "S" {!cir.ptr<!cir.struct<struct "T" {!cir.ptr<!cir.struct<struct "S">>} #cir.record.decl.ast>>} #cir.record.decl.ast>
!ty_T = !cir.struct<struct "T" {!cir.ptr<!ty_S>} #cir.record.decl.ast>

i.e. S repeats the whole definition of T. Ideally it'd reference an incomplete version of T and let T's own definition complete that later, as in:

!ty_S = !cir.struct<struct "S" {!cir.ptr<!cir.struct<struct "T" incomplete>} #cir.record.decl.ast>
!ty_T = !cir.struct<struct "T" {!cir.ptr<!ty_S>} #cir.record.decl.ast>

I spent some time thinking about how to improve this, and I don't think it'll be possible without changes to MLIR ASM printing infra (which may not be accepted upstream). My idea was that, when you're doing the final type printing, if you have struct A that references struct B, and you actually end up inside StructType::print for struct B, it implies mutual recursion (otherwise you would have referenced the type alias for B instead of printing the type). You could have some mechanism to detect that (which is kinda tricky to make reentrant and thread-safe, but doable with enough effort) and print the type as incomplete in that case.

The problem is that type alias construction also uses a dummy AsmPrinter (DummyAliasDialectAsmPrinter), and you don't want to short-circuit the printing in that case, otherwise you'll incorrectly skip over generating type aliases for nested structs. I couldn't think of any good way to distinguish the two cases from inside StructType::print. AsmPrinter doesn't implement RTTI, and there's no member functions I could find to figure out the type of printer. You could rely on a heuristic like "the first time a particular type is being printed, it's the alias printer, and all subsequent times are the actual printer" (since the alias printer does its own cycle checking and should never enter the same type twice), but that seems pretty fragile and prone to problems if the printer behavior changes in the future.

I could make more information available in the AsmPrinter to make this work, but it seems kinda hacky and I don't think upstream will be happy with it (given that the circular printing patches that were originally referenced in this issue have just been languishing). Unless there's some good way to make this work that I've missed or we feel very strongly about improving this further, I'm going to close this out. I don't think mutually recursive structs are super common, so hopefully the current state of affairs isn't too bad in practice.