this will skip all tokens except those in the default recovery set.

types are really just expressions

Inserts a lone element without adding any dependencies from or to it. Returns true if the item already existed in the `TopoSort`

recursively replaces weakly-typed expressions with strong types. ```text x := 42; // x is of type {uint}, which is a weak type y : u16 = x;

todo! get rid of this somehow and just have const_data

zero-sized types should compile to nothing.

This actually will return the post expression *first*. The reason is because the `next` function below always returns the expression on the top of th

If found does not match expected, an error is thrown at the expression This function will also do weak type replacing

Returns the "absolute" type. If the type is distinct, it will return the true underlying type.

Note that `?u64` is an aggregate type but `?^u64` isn't

automagically converts two types into the type that can represent both. this function accepts unknown types. ```text {int} → i8 → i16 → i32 → i64 →

returns whether one type can "fit" into another type as shown in the below diagram. ```text {int} → i8 → i16 → i32 → i64 ↘ ↘ f32 → f64 ↗ ↗ {u

returns true if the type is unknown, or contains unknown, or is an unknown array, etc.

If self is a pointer, this returns the mutability and sub type

only blocks which are actually `break`d or `continue`d out of will get a scopeid

An equality check that ignores distinct types and anonymity. All other types must be exactly equal (i32 == i32, i32 != i64) if `self_can_lose_distinc

Removes the first item with no open dependencies.

Adds padding for the next array item

This converts the address + offset into a single address if needed

builds a depth-first iterator of the given expression and all of it's children. sub expressions are guarenteed to come after their parents, and early

As opposed to `write_all`, this writes a single `Value` to an `offset`

If self is an array, this returns the length and sub type