refactor(codegen): type safe inkwell types

[baszalmstra]

Inkwell uses types that lose a lot of type information. An u8, u16, i8, and 16 are all represented by an IntValue. This takes some careful management of these types. For IntValue the problem is not so bad but for PointerValue and StructValue this is a real issue. By using StructValue you lose all information in the type with what kind of value you are actually working. This is not so much a problem for dynamic types (like Mun structs) but it is a major risk when using abi types. I feel that this is major technical depth.

This PR introduces a new type Value<T> that contains an inkwell value but it is typed on T which is the type that constructed the value. This allows you to write:

let a:Value<SomeStruct>;           // Holds an inkwell StructValue
let b:Value<*const SomeStruct>;    // Holds an inkwell PointerValue

It also allows much cleaner conversion from regular Rust types to inkwell types. e.g.

let a:BasicValueEnum = 3u32.as_value(context).into();
let b:ArrayValue = [0.0f32, 6.0f32].as_value(context).into();
let c:StructValue = (90, true).as_value(context).into();

There are 3 ways to enable custom types to work with this system:

1. Implement the TransparentValue trait which converts the implementor into another Value<T>. But in turn it also allows the implementor to be represented as a Value<Self>:

   use mun_codegen::value::{AsValue, IrValueContext, TransparentValue, Value};
   struct Foo {
      value: u32,
      bar: f32,
   }
   
    impl TransparentValue for Foo {
       type Target = (u32, f32);   
   
        fn as_target_value(&self, c ontext: &IrValueContext) -> Value<Self::Target> {
           (self.value, self.bar).as_value(context)
       }
   }

   The resulting IR type will be an anonymous type: type { u32, f32 }

2. Auto derive the AsValue trait e.g.:

   #[derive(AsValue)]
   #[ir_name = "Foo"]
   pub struct Foo {
       value: u32,
       bar: f32,
   }

   The resulting IR type will be a named type: %Foo = type { u32, f32 }

3. You can also implement all the support traits yourself for a custom type.

I already found a few bugs in the LLVM ir that have been fixed.

TODO

• Refactor abi_types.rs to use the types from Value<T>s
• Refactor the symbol and type-table generation to use the safe new Value<T> types
• Create a procedural macro to validate that a certain structs matches its abi counterpart. (ir::TypeInfo should equal abi::TypeInfo)
• See if we can remove some of the previous implementations (in ir.rs) (do in a later PR)

[codecov]

Codecov Report

Merging #202 into master will decrease coverage by 0.86%.
The diff coverage is 65.85%.

@@            Coverage Diff             @@
##           master     #202      +/-   ##
==========================================
- Coverage   82.95%   82.08%   -0.87%     
==========================================
  Files         163      174      +11     
  Lines       11514    11665     +151     
==========================================
+ Hits         9551     9575      +24     
- Misses       1963     2090     +127     

Impacted Files	Coverage Δ
crates/mun_codegen/src/ir/function.rs	95.83% <ø> (ø)
crates/mun_codegen/src/value/float_value.rs	0.00% <0.00%> (ø)
crates/mun_codegen_macros/src/lib.rs	0.00% <0.00%> (ø)
crates/mun_codegen/src/value/string.rs	21.42% <21.42%> (ø)
crates/mun_codegen/src/ir.rs	47.50% <28.57%> (+4.31%)	⬆️
crates/mun_codegen/src/value/int_value.rs	46.42% <46.42%> (ø)
crates/mun_codegen/src/value/mod.rs	54.83% <54.83%> (ø)
crates/mun_codegen/src/value/global.rs	70.58% <70.58%> (ø)
crates/mun_codegen/src/value/tuple_value.rs	71.42% <71.42%> (ø)
crates/mun_codegen/src/code_gen.rs	89.41% <75.00%> (-4.40%)	⬇️
... and 26 more

---

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 3f67612...305b008. Read the comment docs.

[Wodann]

Props for this change. 👏 I had some minor requests for change.