Flatten typesets

[CohenArthur]

Fixes #674

[CohenArthur]

One issue is that this code does work, when it should not:

type Nothing;
type NullableInt = 15 | Nothing;

func g(n: NullableInt) {}

where x = 16;

g(15);
g(x);
g(Nothing);

and replacing NullableInt's definition with a proper one (int | Nothing) causes the code to no longer work 🙃

[CohenArthur]

Getting closer. Another testcase we must handle before merging this:

type unit;
type bool;
type char;
type int;
type float;
type string;

func fifteen(inner: int) {}

where x = fifteen(14);
where y = fifteen(14 * 12);

[CohenArthur]

• Add as a testcase:

ext func magic() -> int;

type Nothing;
type NullableInt = int | Nothing;

func g(n: NullableInt) {}

g(magic());

[CohenArthur]

One other issue is that we show type errors with the flattened version of the type, so for example it'll show as "expected 15 | 16, got string"

[CohenArthur]

There is an issue when formatting empty typesets, for example the char type if there are no characters in the program. this will be fixed once we address the formatting issues

[CohenArthur]

the only blocker now is the handling of builtin types for arithmetic operations

[CohenArthur]

The issue with arithmetic builtins lie in the expected_arithmetic_types function, where we need to do something a little smarter than recreate our union types.

[CohenArthur]

So turns out we can actually use them as literal types right now :( hmmmm... maybe we could sidestep this and compare their string representation? We can probably do that for all types actually?

[CohenArthur]

However, their string representation probably isn't stored in our symbol table right now... so we'd have to generate it dynamically which sounds worse

[CohenArthur]

Running benchmarks show that storing a string in ast::Node::Constant alongside the Value (so turning the variant into Constant(Value, String)) and making these strings during parsing, using &'ast str as keys instead is just as fast as adding a new Float variant to HashableValue which stores the string representation of the float. Furthermore, this uses a tiny bit more memory, and makes the parser code heavier and harder to read IMO.

Benching code:

fn main() {
    println!("type unit;");
    println!("type bool;");
    println!("type int;");
    println!("type char;");
    println!("type float;");
    println!("type string;");

    for i in 0..99 {
        for _ in 0..100 {
            println!("{{");

            println!("where a{0}i = {0} + {0};", i);
            println!("where a{0}f = {0}.{0} + {0}.{0};", i);

            println!("}};");
        }
    }
}