`array_decl` is ONLY used by `parse_array_decl` to pass it's previously created marker. This allows the array literal to completely replace the array

Used in `const_ty` to report expressions that aren't types

`size` and `align` are in bytes

This might be useful in detecting if a type *needs* an explicit value to be instanced. E.g. ```text my_block : void = { core.println("Hello!"); }; ``

todo: make sure this works for not equal

todo: I don't like the repeated code in `create_mangled_for_concrete_global` `create_mangled_for_concrete_lambda` `create_mangled_for_concrete`

Only call for blocks which had their type previously set by a `break` returns the max of the found expression and the current type of the block todo

For nullable optionals (optionals of non-zero types), this returns None

allows `distinct` types to have the same semantics as other types as long as the inner type matches

For union types (optionals, error unions, and enums) this returns every possible "type" which the sum type might represent. E.g. `?i32` => [i32, nil]

This will clear `inline_comptime_args` and `inline_comptime_tys`

Type information is duplicated between the area in which the lambda header resides, and the area in which the lambda body resides. This function does

this is used so that certain postfix operators are applied after prefix operators. notably, this allows `^foo^` to be parsed as `(^foo)^` and not `^(

`disallow_derefs` disallows `foo^` expressions to be generated `disallow_dot_instantiation` disallows `foo.()`, `foo.{}`, and `foo.[]` expressions to

Used for `return` and `.try`

This returns every body of every defined global

This might be slightly superficial in some scenarios, I'm not sure

This is used for the `as` operator to see whether something can be casted into something else This only allows primitives to be casted to each other,

returns true if two types are too similar to the point that they share common autocasts e.g. i64 and u64 can not be differentiated from each other be

This should be run *after* `Compiler::compile_queued`. `compile_queued` will mark certain builtin globals as "accessed". This function then only popu

This is the function that does the actual work. It iteratively compiles every used function into cranelift IR. This only happens for functions/global

this will handle "resolving" the given location into a final function location

Starts with "_C" Followed by a table of contents, showing a single letter code for each part of the name. See full list of letters above. For each p

Should be called before `Compiler::compile_queued`. `finalize_tys` will calculate the final size, stride, alignment, and `FinalTy` of every `Intern<T

only pass `None` to `entry_point` if your testing type checking and you don't want to worry about the entry point

On top of separating the path into the module name and the file components, this will also strip any ".capy" at the end of a component, and will repla