Witness tables for all enums are shared

[juliusikkala]

interface IThing
{
    void declareSelf();
}

enum FirstEnum
{
    A,
    B
};

enum SecondEnum
{
    C,
    D
};

extension FirstEnum: IThing
{
    void declareSelf()
    {
        printf("FirstEnum: %d\n", this);
    }
}

extension SecondEnum: IThing
{
    void declareSelf()
    {
        printf("SecondEnum: %d\n", this);
    }
}

void declareType<T: IThing>(T val)
{
    val.declareSelf();
}

export __extern_cpp int main()
{
    declareType(FirstEnum.A);
    declareType(SecondEnum.C);
    return 0;
}

Surprisingly, this prints "FirstEnum" twice!
Before lowering to IR, the witness tables have distinct pointers. After lowering, they are the same. Perhaps there is some erroneous caching going on here.

The IR witness table is also implemented for Int, but I guess that isn't a problem?

witness_table %199      : witness_table_t(%IThing)(Int)
{
        witness_table_entry(%115,%declareSelf)
}

This issue is blocking #6916, because this prevents disambiguating between separate enums (which should have different witness tables, even if the IR type is the same), so an incorrect catch block can run if there are multiple catches.

[csyonghe]

The problem here is our IR doesn't have a notion of enum types, and we lowered all enums to int during initial IR lowering.

This is too early. We need to have something like IREnumType in the IR, and we also need to have a CastEnumToInt and CastIntToEnum opcodes.

By representing enum types as proper IR level types, we will be able to define witness tables for enum types.

[jkwak-work]

I think this is related to one of my PR 6417

• Make IRWitnessTable HOISTABLE #6417

The problem 5 in the description discusses that I had two options and I took the easy solution.

I am pasting it here for a quick reference.

Solution for "5. Different import/export mangled names were used for the same Witness-table when its type is "enum" interface."
This issue was found while testing with Falcor tests where it uses Conformance-type feature of Slang.
We are using different import and export mangled names for a same Witness-table when the witness-table is for "Enum" interface.

The way we simplify the implementation of "Enum" causes a problem when it comes to generate export/import for the witness-table. And the exact repro step is still unclear.

There were two suggested solutions for the problem and this PR adopted the first option for now. Maybe we want to improve it with the second option later.

option 1, when we produce mangled names for those witness-table, we can use a mangled name with the underlying "int" type instead of the name of the enum type. In this way, all witness-tables for enum types whose underlying type is same will get the same mangled name. It will allow us to deduplicate the witness-table during the linking.

option 2, we can preserve type info for enum type when generating IR. We can still erase all other uses of the type info of enum types for now. But when we generate the witness-table, instead of filling the conforming type operand to IntType, we fill it as EnumType(IntType) where EnumType is a new global IROp code to represent all enum types (like InterfaceType/StructType). This way the operands for the two witness-tables will be different.

"option 1" is more quick and dirty and "option 2" is more proper way to address it.
I should go with "option 1" and improve it with "option 2" approach later.