To explain this a bit more...

When you have:

x = {1} || {"a"}

what type does x has? Normally it's the union of both types, so Tuple(Int32) | Tuple(String). However, for this particular case, the compiler turns it into Tuple(Int32 | String). This is done for the cases where you do stuff like this:

def foo
  if some_condition
    {:error, null}
  else
    {:ok, 1}
  end
end

The return type is Tuple(Symbol, Int32?), and it's easier to deal with (you probably don't expect a union of tuples but a tuple of unions).

But maybe that wasn't a good idea after all (it makes the compiler's code a lot more complex). This special logic also happens for named tuples.

Back to the original issues, when deciding what's the type of a union of metaclasses, we usually do it first for the instance types, and then obtain the metaclass from there. The bug was that if this is done for tuple metaclasses, the type is the metaclass of a tuple of unions (incorrect), instead of the metaclass of a union of tuples (correct). So for tuple metaclasses it's always just the simple union of metaclasses.