Update version number for lsp-extension

Update reid-llvm-lib
Update version to 1.0.0
2025-09-07 15:56:41 +03:00 · 2025-09-07 15:40:22 +03:00 · 2025-09-07 15:39:53 +03:00 · 2025-09-07 15:35:10 +03:00 · 2025-09-07 15:34:22 +03:00 · 2025-08-17 19:36:02 +03:00
70 changed files with 4436 additions and 5391 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -0,0 +1,3 @@
+[submodule "reid-llvm-lib"]
+	path = reid-llvm-lib
+	url = gitea@git.teascade.net:teascade/reid-llvm-lib.git
--- a/Cargo.lock
+++ b/Cargo.lock
@ -17,12 +17,59 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"

+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anyhow"
 version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"

+[[package]]
+name = "argh"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ff18325c8a36b82f992e533ece1ec9f9a9db446bd1c14d4f936bac88fcd240"
+dependencies = [
+ "argh_derive",
+ "argh_shared",
+ "rust-fuzzy-search",
+]
+
+[[package]]
+name = "argh_derive"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b2b83a50d329d5d8ccc620f5c7064028828538bdf5646acd60dc1f767803"
+dependencies = [
+ "argh_shared",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "argh_shared"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a464143cc82dedcdc3928737445362466b7674b5db4e2eb8e869846d6d84f4f6"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.88"
@ -78,6 +125,12 @@ version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"

+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
 [[package]]
 name = "bytes"
 version = "1.10.1"
@ -99,6 +152,20 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"

+[[package]]
+name = "chrono"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
 [[package]]
 name = "colored"
 version = "3.0.0"
@ -108,6 +175,12 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
@ -250,12 +323,42 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"

+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"

+[[package]]
+name = "iana-time-zone"
+version = "0.1.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.0.0"
@ -374,12 +477,33 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "is-terminal"
+version = "0.4.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"

+[[package]]
+name = "js-sys"
+version = "0.3.77"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@ -422,6 +546,12 @@ dependencies = [
 "scopeguard",
 ]

+[[package]]
+name = "log"
+version = "0.4.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
 [[package]]
 name = "lsp-types"
 version = "0.94.1"
@ -654,38 +784,55 @@ checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"

 [[package]]
 name = "reid"
-version = "1.0.0-beta.2"
+version = "1.0.0"
 dependencies = [
+ "argh",
 "colored",
+ "log",
 "reid-lib",
+ "stderrlog",
 "thiserror",
 ]

 [[package]]
-name = "reid-lib"
-version = "1.0.0-beta.2"
-dependencies = [
- "llvm-sys",
- "thiserror",
-]
-
-[[package]]
-name = "reid-lsp"
-version = "0.1.0"
+name = "reid-language-server"
+version = "1.0.0"
 dependencies = [
 "dashmap 6.1.0",
 "reid",
+ "serde",
+ "serde_json",
 "socket",
 "tokio",
 "tower-lsp",
 ]

+[[package]]
+name = "reid-lib"
+version = "1.0.0"
+dependencies = [
+ "llvm-sys",
+ "thiserror",
+]
+
+[[package]]
+name = "rust-fuzzy-search"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a157657054ffe556d8858504af8a672a054a6e0bd9e8ee531059100c0fa11bb2"
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"

+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
 [[package]]
 name = "ryu"
 version = "1.0.20"
@ -800,6 +947,19 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"

+[[package]]
+name = "stderrlog"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c910772f992ab17d32d6760e167d2353f4130ed50e796752689556af07dc6b"
+dependencies = [
+ "chrono",
+ "is-terminal",
+ "log",
+ "termcolor",
+ "thread_local",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.104"
@ -822,6 +982,15 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "termcolor"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@ -842,6 +1011,15 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.1"
@ -1017,6 +1195,132 @@ version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"

+[[package]]
+name = "wasm-bindgen"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+dependencies = [
+ "bumpalo",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "winapi-util"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
--- a/README.md
+++ b/README.md
@ -73,7 +73,12 @@ Big features that I want later but are not necessary:
 - ~~Asymmetric binary operations (e.g. string + u32)~~ (DONE)
 - ~~Error handling~~ (Not Doing It)
 - ~~Lexing & parsing of whitespace and comments as well~~ (DONE)
- LSP implementation
+- ~~LSP implementation~~ (DONE) 
+  - ~~Syntax Highlighting~~ (DONE)
+  - ~~Semantic Highlighting~~ (DONE)
+  - ~~Go-To-Definition~~ (DONE)
+  - ~~Find-All-References~~ (DONE)
+  - ~~Refactoring~~ (DONE)

 Smaller features:
 - ~~Hex-numbers~~ (DONE)
--- a/documentation/intrinsics.md
+++ b/documentation/intrinsics.md
@ -7,16 +7,6 @@ pre-existing binary-operators, but also some regular functions and associated
 functions (that every type has by-default). This document lists them all (except
 for the binary operators, because there are hundreds of those).

-### Global Intrinsics
-
-#### `malloc(size: u64) -> *u8`
-
-Allocates `size` bytes and returns a pointer of `u8` of length `size`.
-
-```rust
-i32::malloc(40); // Reserves 40 bytes
-```
-
 ### Macro Intrinsics

 #### `include_bytes!(path: *char) -> &[u8; _]`
@ -43,15 +33,155 @@ Returns a null-pointer of type `T`.
 i32::null(); // Returns *i32 (null-ptr)
 ```

+#### `<T>::is_null(val: T) -> bool`
+
+Returns a boolean representing if `val` is a nullptr or not.
+
+```rust
+i32::is_null(i32::null()); // Returns true
+```
+
 #### `<T>::malloc(size: u64) -> *T`

 Allocates `T::sizeof() * size` bytes and returns a pointer to `T`.

-**Note:** This does not seem to work correctly currently.
-
 ```rust
 i32::malloc(30); // Returns *i32

 // Equivalent to
 malloc(i32::sizeof() * 30) as *i32
-```
+```
+
+#### `<T>::memcpy(destination: *T, source: *T, size: u64)`
+
+Copies `T::sizeof() * size` bytes from pointer `source` to pointer
+`destination`.
+
+```rust
+let a = i32::malloc(30);
+let b = i32::malloc(30);
+
+// Copies the contents from b to a
+i32::memcpy(a, b, 30);
+```
+
+
+#### `<T>::min(a: T, b: T) -> T`
+*Note: (only on integer- and floating-point values)*
+
+Returns the smaller of `a` and `b`.
+
+#### `<T>::max(a: T, b: T) -> T`
+*Note: (only on integer- and floating-point values)*
+
+Returns the larger of `a` and `b`.
+
+#### `<T>::abs(value: T) -> T`
+*Note: (only on signed integer and floating-point values)*
+
+Returns the absolute value of `value`.
+
+#### `<T>::sqrt(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates the square-root of `value`
+
+#### `<T>::pow(value: T, exponent: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Returns `value` raised to the exponent of `exponent`.
+
+#### `<T>::powi(value: T, exponent: u64) -> T`
+*Note: (only on floating-point numbers)*
+
+Returns `value` raised to the exponent of `exponent`.
+
+#### `<T>::sin(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates sine of `value`
+
+#### `<T>::cos(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates cosine of `value`
+
+#### `<T>::tan(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates tangent of `value`
+
+#### `<T>::asin(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates arcsine of `value`
+
+#### `<T>::acos(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates arccosine of `value`
+
+#### `<T>::atan(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates arctangent of `value`
+
+#### `<T>::atan2(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates 2-argument arctangent of `value`
+
+#### `<T>::sinh(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates hyperbolic sine of `value`
+
+#### `<T>::cosh(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates hyperbolic cosine of `value`
+
+#### `<T>::tanh(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Calculates hyperbolic tangent of `value`
+
+#### `<T>::log(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Returns logₑ of `value`
+
+#### `<T>::log2(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Returns log₂ of `value`
+
+#### `<T>::log10(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Returns log₁₀ of `value`
+
+#### `<T>::round(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Rounds `value` to the nearest integer
+
+#### `<T>::trunc(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Truncates `value` to the integer nearest to `0`.
+
+#### `<T>::ceil(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Rounds `value` towards positive infinity.
+
+#### `<T>::floor(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Rounds `value` towards negative infinity.
+
+#### `<T>::even(value: T) -> T`
+*Note: (only on floating-point numbers)*
+
+Rounds `value` to the closest even integer.
--- a/documentation/standard_library.md
+++ b/documentation/standard_library.md
@ -64,10 +64,6 @@ _deprecated: Use `String::concat()`_

 ## General

-#### `pub fn allocate(size: u64) -> *u8`
-
-Unsafely allocates `size` bytes of memory from the stack, and returns a pointer to it, which must be manually freed.
-
 ## Maths

 #### `pub fn clamp(min: f32, max: f32, value: f32) -> f32`
--- a/examples/array_structs.reid
+++ b/examples/array_structs.reid
@ -20,7 +20,7 @@ fn main() -> u32 {
    let boop: f32 = 3;

    let mut a = &mut value;
-
+    
    *a.second[2] = 5;

    return *a.second[2];
--- a/examples/associated_functions.reid
+++ b/examples/associated_functions.reid
@ -2,11 +2,14 @@ import std::print;
 import std::from_str;
 import std::String;

+/// Asd
 struct Otus {
    field: u32,
 }

 impl Otus {
+    /// Some test documentation here.
+    /// On a second line
    fn test(&self) -> u32 {
        *self.field
    }
@ -18,12 +21,18 @@ impl i32 {
    }
 }

+/// Hello there!
+fn test() {
+
+}
+
 fn main() -> u32 {
    let otus = Otus { field: 17 };
    print(from_str("otus: ") + Otus::test(&otus) as u64);
    print(from_str("i32: ") + i32::test(54) as u64);
    print(from_str("sizeof i32: ") + i32::sizeof());

+
    let nullptr = i32::null();
    let mut list = u64::malloc(15);
    list[4] = 17;
--- a/examples/associated_functions_shorthand.reid
+++ b/examples/associated_functions_shorthand.reid
@ -22,6 +22,8 @@ fn main() -> u32 {
    let otus = Otus { field: 17 };
    print(from_str("otus: ") + otus.test() as u64);

+    otus.field;
+

    return otus.test();
 }
--- a/examples/borrow_hard.reid
+++ b/examples/borrow_hard.reid
@ -1,5 +1,6 @@
 // Arithmetic, function calls and imports!

+/// Test stuff
 fn changer(param: &mut u32) {
  *param = 17;
 }
--- a/examples/compilcated_main.reid
+++ b/examples/compilcated_main.reid
@ -0,0 +1,10 @@
+import complicated_imported::Foo;
+import complicated_imported::A;
+import complicated_imported::AResult;
+
+fn main() -> i32 {
+    let foo = Foo {};
+    let a = A::new();
+    foo.foo(&a.a);
+    return 0;
+}
--- a/examples/complicated_imported.reid
+++ b/examples/complicated_imported.reid
@ -0,0 +1,12 @@
+struct A {}
+struct AResult { a: A }
+impl A {
+    pub fn new() -> AResult {
+        AResult { a: A {} }
+    }
+}
+
+struct Foo {}
+impl Foo {
+    pub fn foo(&self, a: &A) {}
+}
--- a/examples/fibonacci.reid
+++ b/examples/fibonacci.reid
@ -1,13 +1,12 @@
-a
-(
-    b
-)
-x
-(
-    (
-        c
-        xyz
-    )
-)
-(
-a
+// Main
+fn main() -> bool {
+    return 144 == fibonacci(0xc);
+}
+
+// Fibonacci
+fn fibonacci(value: u16) -> u16 {
+    if value <= 2 {
+        return 1;
+    }
+    fibonacci(value - 1) + fibonacci(value - 2)
+}
--- a/examples/foreign_init.reid
+++ b/examples/foreign_init.reid
@ -0,0 +1,6 @@
+import foreign_struct::Vec2;
+
+fn main() -> u32 {
+    let a = Vec2 {x: 16, y: 32};
+    return a.x;
+}
--- a/examples/foreign_struct.reid
+++ b/examples/foreign_struct.reid
@ -0,0 +1 @@
+struct Vec2 { x: u32, y: u32 }
--- a/examples/loop_edge_case.reid
+++ b/examples/loop_edge_case.reid
@ -0,0 +1,9 @@
+fn main() -> i32 {
+    for i in 0..1 {
+        let j = i;
+        if i != j {
+            return 1;
+        }
+    }
+    return 0;
+}
--- a/examples/math_intrinsics.reid
+++ b/examples/math_intrinsics.reid
@ -0,0 +1,15 @@
+
+extern fn printf(message: *char, num: f64);
+
+fn main() -> i32 {
+    let b = 5;
+    let mut otus = i32::malloc(1);
+    otus[0] = 10500300;
+    let potus = i32::malloc(1);
+    i32::memcpy(potus, otus, 1);
+
+    printf("log10 %f\n", f64::round(123.3) as f64);
+    printf("sqrt %f\n", f64::sqrt(2) as f64);
+    printf("log10 %f\n", potus[0] as f64);
+    return potus[0];
+}
--- a/examples/module_importee.reid
+++ b/examples/module_importee.reid
@ -0,0 +1,8 @@
+
+struct Otus {
+    field: u32,
+}
+
+pub fn test() -> Otus {
+    Otus {field: 4}
+}
--- a/examples/module_impoter.reid
+++ b/examples/module_impoter.reid
@ -0,0 +1,11 @@
+// Arithmetic, function calls and imports!
+
+import module_importee::Otus;
+import module_importee::test;
+
+fn main() -> u32 {
+  let value = 0b110;
+  let other = 0o17;
+  
+  return value * other + test().field * -value;
+}
--- a/examples/nullptr_comparison.reid
+++ b/examples/nullptr_comparison.reid
@ -0,0 +1,4 @@
+fn main() -> bool {
+    let ptr = i32::null();
+    return i32::is_null(ptr);
+}
--- a/libtest.sh
+++ b/libtest.sh
@ -16,7 +16,7 @@ BINARY="$(echo $1 | cut -d'.' -f1)"".out"

 echo $1

-cargo run  --example cli $@ && \
+cargo run -p reid -- $@ && \
 ./$BINARY ; echo "Return value: ""$?"

 ## Command from: clang -v hello.o -o test
--- a/1
+++ b/1
@ -0,0 +1 @@
+Subproject commit 100cd96a6dc3bb882ce60e78c4eab47e77fdd8c4
--- a/reid-llvm-lib/Cargo.toml
+++ b/reid-llvm-lib/Cargo.toml
@ -1,12 +0,0 @@
-[package]
-name = "reid-lib"
-version = "1.0.0-beta.2"
-edition = "2024"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-## LLVM Bindings
-llvm-sys = {version ="201.0.1" }
-## Make it easier to generate errors
-thiserror = "1.0.44"
--- a/reid-llvm-lib/examples/libtest.rs
+++ b/reid-llvm-lib/examples/libtest.rs
@ -1,56 +0,0 @@
-use reid_lib::{CmpPredicate, ConstValueKind, Context, FunctionFlags, Instr, TerminatorKind, Type};
-
-fn main() {
-    use ConstValueKind::*;
-    use Instr::*;
-
-    let context = Context::new("libtest");
-
-    let module = context.module("test", true);
-
-    let main = module.function("main", None, Type::I32, Vec::new(), FunctionFlags::default());
-    let mut m_entry = main.block("entry");
-
-    let fibonacci = module.function("fibonacci", None, Type::I32, vec![Type::I32], FunctionFlags::default());
-
-    let arg = m_entry.build_named("const", Constant(I32(5))).unwrap();
-    let fibonacci_call = m_entry
-        .build_named("const", FunctionCall(fibonacci.value(), vec![arg]))
-        .unwrap();
-    m_entry.terminate(TerminatorKind::Ret(fibonacci_call)).unwrap();
-
-    let mut f_entry = fibonacci.block("entry");
-
-    let num_3 = f_entry.build_named("const", Constant(I32(3))).unwrap();
-    let param_n = f_entry.build_named("param", Param(0)).unwrap();
-    let cond = f_entry
-        .build_named("cmp", ICmp(CmpPredicate::LT, param_n, num_3))
-        .unwrap();
-
-    let mut then_b = fibonacci.block("then");
-    let mut else_b = fibonacci.block("else");
-
-    f_entry
-        .terminate(TerminatorKind::CondBr(cond, then_b.value(), else_b.value()))
-        .unwrap();
-
-    let ret_const = then_b.build_named("const", Constant(I32(1))).unwrap();
-    then_b.terminate(TerminatorKind::Ret(ret_const)).unwrap();
-
-    let const_1 = else_b.build_named("const", Constant(I32(1))).unwrap();
-    let const_2 = else_b.build_named("const", Constant(I32(2))).unwrap();
-    let param_1 = else_b.build_named("sub", Sub(param_n, const_1)).unwrap();
-    let param_2 = else_b.build_named("sub", Sub(param_n, const_2)).unwrap();
-    let call_1 = else_b
-        .build_named("fibonacci", FunctionCall(fibonacci.value(), vec![param_1]))
-        .unwrap();
-    let call_2 = else_b
-        .build_named("fibonacci", FunctionCall(fibonacci.value(), vec![param_2]))
-        .unwrap();
-
-    let add = else_b.build_named("add", Add(call_1, call_2)).unwrap();
-
-    else_b.terminate(TerminatorKind::Ret(add)).unwrap();
-
-    context.compile(None, Vec::new());
-}
--- a/reid-llvm-lib/src/builder.rs
+++ b/reid-llvm-lib/src/builder.rs
@ -1,782 +0,0 @@
-//! This module contains simply [`Builder`] and it's related utility Values.
-//! Builder is the actual struct being modified when building the LLIR.
-
-use std::{cell::RefCell, rc::Rc};
-
-use crate::{
-    Block, BlockData, CompileResult, ConstValueKind, CustomTypeKind, ErrorKind, FunctionData, Instr, InstructionData,
-    ModuleData, NamedStruct, TerminatorKind, Type, TypeCategory, TypeData,
-    debug_information::{
-        DebugInformation, DebugLocationValue, DebugMetadataValue, DebugScopeValue, InstructionDebugRecordData,
-    },
-    util::match_types,
-};
-
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
-pub struct ModuleValue(pub(crate) usize);
-
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
-pub struct TypeValue(pub(crate) ModuleValue, pub(crate) usize);
-
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
-pub struct FunctionValue(pub(crate) ModuleValue, pub(crate) usize);
-
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
-pub struct BlockValue(pub(crate) FunctionValue, pub(crate) usize);
-
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
-pub struct InstructionValue(pub(crate) BlockValue, pub(crate) usize);
-
-#[derive(Debug, Clone, Hash, Copy, PartialEq, Eq)]
-pub struct ConstantValue(pub(crate) ModuleValue, pub(crate) usize);
-
-#[derive(Debug, Clone, Hash, Copy, PartialEq, Eq)]
-pub struct GlobalValue(pub(crate) ModuleValue, pub(crate) usize);
-
-#[derive(Clone)]
-pub struct ModuleHolder {
-    pub(crate) value: ModuleValue,
-    pub(crate) data: ModuleData,
-    pub(crate) functions: Vec<FunctionHolder>,
-    pub(crate) types: Vec<TypeHolder>,
-    pub(crate) debug_information: Option<DebugInformation>,
-    pub(crate) constants: Vec<ConstantValueHolder>,
-    pub(crate) globals: Vec<GlobalValueHolder>,
-}
-
-#[derive(Clone)]
-pub struct ConstantValueHolder {
-    pub(crate) value: ConstantValue,
-    pub(crate) kind: ConstValueKind,
-}
-#[derive(Clone)]
-pub struct GlobalValueHolder {
-    pub(crate) value: GlobalValue,
-    pub(crate) name: String,
-    pub(crate) initializer: ConstantValue,
-}
-
-#[derive(Clone)]
-pub struct TypeHolder {
-    pub(crate) value: TypeValue,
-    pub(crate) data: TypeData,
-}
-
-#[derive(Clone)]
-pub struct FunctionHolder {
-    pub(crate) value: FunctionValue,
-    pub(crate) data: FunctionData,
-    pub(crate) blocks: Vec<BlockHolder>,
-    /// Debug scope value of this current function
-    pub(crate) debug_info: Option<DebugScopeValue>,
-}
-
-#[derive(Clone)]
-pub struct BlockHolder {
-    pub(crate) value: BlockValue,
-    pub(crate) data: BlockData,
-    pub(crate) instructions: Vec<InstructionHolder>,
-}
-
-#[derive(Clone)]
-pub struct InstructionHolder {
-    pub(crate) value: InstructionValue,
-    pub(crate) data: InstructionData,
-    pub(crate) name: String,
-    pub(crate) record: Option<InstructionDebugRecordData>,
-}
-
-#[derive(Clone)]
-pub(crate) struct Builder {
-    pub(crate) modules: Rc<RefCell<Vec<ModuleHolder>>>,
-    pub(crate) producer: String,
-}
-
-impl Builder {
-    pub fn new(producer: String) -> Builder {
-        Builder {
-            modules: Rc::new(RefCell::new(Vec::new())),
-            producer,
-        }
-    }
-
-    pub(crate) fn add_module(&self, data: ModuleData) -> ModuleValue {
-        let value = ModuleValue(self.modules.borrow().len());
-        self.modules.borrow_mut().push(ModuleHolder {
-            value,
-            data,
-            functions: Vec::new(),
-            types: Vec::new(),
-            debug_information: None,
-            constants: Vec::new(),
-            globals: Vec::new(),
-        });
-        value
-    }
-
-    pub(crate) fn set_debug_information(&self, mod_val: &ModuleValue, debug_info: DebugInformation) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(mod_val.0);
-            module.debug_information = Some(debug_info);
-        }
-    }
-
-    pub(crate) unsafe fn add_type(&self, mod_val: &ModuleValue, data: TypeData) -> TypeValue {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(mod_val.0);
-            let value = TypeValue(module.value, module.types.len());
-            module.types.push(TypeHolder { value, data });
-            value
-        }
-    }
-
-    pub(crate) unsafe fn add_function(&self, mod_val: &ModuleValue, data: FunctionData) -> FunctionValue {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(mod_val.0);
-            let value = FunctionValue(module.value, module.functions.len());
-            module.functions.push(FunctionHolder {
-                value,
-                data,
-                blocks: Vec::new(),
-                debug_info: None,
-            });
-            value
-        }
-    }
-
-    pub(crate) unsafe fn add_block(&self, fun_val: &FunctionValue, data: BlockData) -> BlockValue {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(fun_val.0.0);
-            let function = module.functions.get_unchecked_mut(fun_val.1);
-            let value = BlockValue(function.value, function.blocks.len());
-            function.blocks.push(BlockHolder {
-                value,
-                data,
-                instructions: Vec::new(),
-            });
-            value
-        }
-    }
-
-    pub(crate) unsafe fn add_instruction(
-        &self,
-        block_val: &BlockValue,
-        data: InstructionData,
-        name: String,
-    ) -> CompileResult<InstructionValue> {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(block_val.0.0.0);
-            let function = module.functions.get_unchecked_mut(block_val.0.1);
-            let block = function.blocks.get_unchecked_mut(block_val.1);
-            let value = InstructionValue(block.value, block.instructions.len());
-            block.instructions.push(InstructionHolder {
-                value,
-                data,
-                name,
-                record: None,
-            });
-
-            // Drop modules so that it is no longer mutable borrowed
-            // (check_instruction requires an immutable borrow).
-            drop(modules);
-
-            self.check_instruction(&value)?;
-            Ok(value)
-        }
-    }
-
-    pub(crate) unsafe fn build_constant(&self, module: ModuleValue, kind: ConstValueKind) -> ConstantValue {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(module.0);
-            let value = ConstantValue(module.value, module.constants.len());
-            module.constants.push(ConstantValueHolder { value, kind });
-            value
-        }
-    }
-
-    pub(crate) unsafe fn add_global(
-        &self,
-        module: ModuleValue,
-        name: String,
-        initializer: ConstantValue,
-    ) -> GlobalValue {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(module.0);
-            let value = GlobalValue(module.value, module.globals.len());
-            module.globals.push(GlobalValueHolder {
-                value,
-                name,
-                initializer,
-            });
-            value
-        }
-    }
-
-    pub(crate) unsafe fn find_function(&self, module: ModuleValue, name: &String) -> Option<FunctionValue> {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(module.0);
-            module.functions.iter().find(|f| f.data.name == *name).map(|f| f.value)
-        }
-    }
-
-    pub(crate) unsafe fn add_instruction_location(&self, value: &InstructionValue, location: DebugLocationValue) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(value.0.0.0.0);
-            let function = module.functions.get_unchecked_mut(value.0.0.1);
-            let block = function.blocks.get_unchecked_mut(value.0.1);
-            let instr = block.instructions.get_unchecked_mut(value.1);
-            instr.data.location = Some(location)
-        }
-    }
-
-    pub(crate) unsafe fn add_instruction_metadata(&self, value: &InstructionValue, metadata: DebugMetadataValue) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(value.0.0.0.0);
-            let function = module.functions.get_unchecked_mut(value.0.0.1);
-            let block = function.blocks.get_unchecked_mut(value.0.1);
-            let instr = block.instructions.get_unchecked_mut(value.1);
-            instr.data.meta = Some(metadata)
-        }
-    }
-
-    pub(crate) unsafe fn add_instruction_record(&self, value: &InstructionValue, record: InstructionDebugRecordData) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(value.0.0.0.0);
-            let function = module.functions.get_unchecked_mut(value.0.0.1);
-            let block = function.blocks.get_unchecked_mut(value.0.1);
-            let instr = block.instructions.get_unchecked_mut(value.1);
-            instr.record = Some(record)
-        }
-    }
-
-    pub(crate) unsafe fn set_debug_subprogram(&self, value: &FunctionValue, subprogram: DebugScopeValue) {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(value.0.0);
-            let function = module.functions.get_unchecked_mut(value.1);
-            function.debug_info = Some(subprogram)
-        }
-    }
-
-    pub(crate) unsafe fn terminate(&self, block: &BlockValue, value: TerminatorKind) -> CompileResult<()> {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(block.0.0.0);
-            let function = module.functions.get_unchecked_mut(block.0.1);
-            let block = function.blocks.get_unchecked_mut(block.1);
-            if let Some(_) = &block.data.terminator {
-                Err(ErrorKind::Null)
-            } else {
-                block.data.terminator = Some(value);
-                Ok(())
-            }
-        }
-    }
-
-    pub(crate) unsafe fn set_terminator_location(
-        &self,
-        block: &BlockValue,
-        location: DebugLocationValue,
-    ) -> CompileResult<()> {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(block.0.0.0);
-            let function = module.functions.get_unchecked_mut(block.0.1);
-            let block = function.blocks.get_unchecked_mut(block.1);
-            if let Some(_) = &block.data.terminator_location {
-                Err(ErrorKind::Null)
-            } else {
-                block.data.terminator_location = Some(location);
-                Ok(())
-            }
-        }
-    }
-
-    pub(crate) unsafe fn delete_block(&self, block: &BlockValue) -> CompileResult<()> {
-        unsafe {
-            let mut modules = self.modules.borrow_mut();
-            let module = modules.get_unchecked_mut(block.0.0.0);
-            let function = module.functions.get_unchecked_mut(block.0.1);
-            let block = function.blocks.get_unchecked_mut(block.1);
-            block.data.deleted = true;
-            Ok(())
-        }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) unsafe fn module_data(&self, value: &ModuleValue) -> ModuleData {
-        unsafe { self.modules.borrow().get_unchecked(value.0).data.clone() }
-    }
-
-    pub(crate) unsafe fn function_data(&self, value: &FunctionValue) -> FunctionData {
-        unsafe {
-            self.modules
-                .borrow()
-                .get_unchecked(value.0.0)
-                .functions
-                .get_unchecked(value.1)
-                .data
-                .clone()
-        }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) unsafe fn block_data(&self, value: &BlockValue) -> BlockData {
-        unsafe {
-            self.modules
-                .borrow()
-                .get_unchecked(value.0.0.0)
-                .functions
-                .get_unchecked(value.0.1)
-                .blocks
-                .get_unchecked(value.1)
-                .data
-                .clone()
-        }
-    }
-
-    pub(crate) unsafe fn instr_data(&self, value: &InstructionValue) -> InstructionData {
-        unsafe {
-            self.modules
-                .borrow()
-                .get_unchecked(value.0.0.0.0)
-                .functions
-                .get_unchecked(value.0.0.1)
-                .blocks
-                .get_unchecked(value.0.1)
-                .instructions
-                .get_unchecked(value.1)
-                .data
-                .clone()
-        }
-    }
-
-    pub(crate) unsafe fn type_data(&self, value: &TypeValue) -> TypeData {
-        unsafe {
-            self.modules
-                .borrow()
-                .get_unchecked(value.0.0)
-                .types
-                .get_unchecked(value.1)
-                .data
-                .clone()
-        }
-    }
-
-    pub(crate) fn find_module<'ctx>(&'ctx self, value: ModuleValue) -> ModuleHolder {
-        unsafe { self.modules.borrow().get_unchecked(value.0).clone() }
-    }
-
-    pub(crate) fn get_modules(&self) -> Rc<RefCell<Vec<ModuleHolder>>> {
-        self.modules.clone()
-    }
-
-    pub(crate) fn get_global_initializer(&self, value: GlobalValue) -> ConstantValue {
-        unsafe {
-            let modules = self.modules.borrow();
-            let module = modules.get_unchecked(value.0.0);
-            let global = module.globals.get_unchecked(value.1);
-            global.initializer
-        }
-    }
-
-    pub(crate) fn get_const_kind(&self, value: ConstantValue) -> ConstValueKind {
-        unsafe {
-            let modules = self.modules.borrow();
-            let module = modules.get_unchecked(value.0.0);
-            let constant = module.constants.get_unchecked(value.1);
-            constant.kind.clone()
-        }
-    }
-
-    pub fn check_instruction(&self, instruction: &InstructionValue) -> CompileResult<()> {
-        unsafe {
-            match self.instr_data(&instruction).kind {
-                Instr::Param(_) => Ok(()),
-                Instr::Constant(_) => Ok(()),
-                Instr::Add(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category().integer() {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::FAdd(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::Sub(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category().integer() {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::FSub(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::Mul(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category().integer() {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::FMul(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::UDiv(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::UnsignedInteger {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::SDiv(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::SignedInteger {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::FDiv(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::URem(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::UnsignedInteger {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::SRem(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::SignedInteger {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::FRem(lhs, rhs) => {
-                    if match_types(&lhs, &rhs, &self)?.category() == TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null)
-                    }
-                }
-                Instr::And(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::Or(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::XOr(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::ICmp(_, lhs, rhs) => {
-                    let t = match_types(&lhs, &rhs, self)?;
-                    if t.category().comparable() || !t.category().integer() {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: Types not comparable
-                    }
-                }
-                Instr::FCmp(_, lhs, rhs) => {
-                    let t = match_types(&lhs, &rhs, self)?;
-                    if t.category().comparable() || t.category() != TypeCategory::Real {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: Types not comparable
-                    }
-                }
-                Instr::FunctionCall(fun, params) => {
-                    let param_types = self.function_data(&fun).params;
-                    if param_types.len() != params.len() {
-                        return Err(ErrorKind::Null); // TODO error: invalid amount of params
-                    }
-                    for (a, b) in param_types.iter().zip(params) {
-                        if *a != b.get_type(&self)? {
-                            return Err(ErrorKind::Null); // TODO error: params do not match
-                        }
-                    }
-                    Ok(())
-                }
-                Instr::Phi(vals) => {
-                    let mut iter = vals.iter();
-                    // TODO error: Phi must contain at least one item
-
-                    // TODO error: compile can actually crash here if any of the
-                    // incoming values come from blocks that are added later
-                    // than the one where this one exists.
-
-                    let first = iter.next().ok_or(ErrorKind::Null)?;
-                    for item in iter {
-                        match_types(first, item, &self)?;
-                    }
-                    Ok(())
-                }
-                Instr::Alloca(_) => Ok(()),
-                Instr::Load(ptr, load_ty) => {
-                    let ptr_ty = ptr.get_type(&self)?;
-                    if let Type::Ptr(ptr_ty_inner) = ptr_ty {
-                        if *ptr_ty_inner == load_ty {
-                            Ok(())
-                        } else {
-                            Err(ErrorKind::Null) // TODO error: inner type mismatch
-                        }
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: not a pointer
-                    }
-                }
-                Instr::Store(ptr, _) => {
-                    let ty = ptr.get_type(&self)?;
-                    if let Type::Ptr(_) = ty {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: not a pointer
-                    }
-                }
-                Instr::ArrayAlloca(_, val) => {
-                    if val.get_type(self)?.category() == TypeCategory::UnsignedInteger {
-                        Ok(())
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: not a pointer
-                    }
-                }
-                Instr::GetElemPtr(ptr_val, _) => {
-                    let ptr_ty = ptr_val.get_type(&self)?;
-                    match ptr_ty {
-                        Type::Ptr(_) => Ok(()),
-                        _ => Err(ErrorKind::Null),
-                    }
-                }
-                Instr::GetStructElemPtr(ptr_val, idx) => {
-                    let ptr_ty = ptr_val.get_type(&self)?;
-                    if let Type::Ptr(ty) = ptr_ty {
-                        if let Type::CustomType(val) = *ty {
-                            match self.type_data(&val).kind {
-                                CustomTypeKind::NamedStruct(NamedStruct(_, fields)) => {
-                                    if fields.len() <= idx as usize {
-                                        return Err(ErrorKind::Null); // TODO error: no such field
-                                    }
-                                }
-                            }
-                            Ok(())
-                        } else {
-                            Err(ErrorKind::Null) // TODO error: not a struct
-                        }
-                    } else {
-                        Err(ErrorKind::Null) // TODO error: not a pointer
-                    }
-                }
-                Instr::ExtractValue(val, _) => {
-                    let val_ty = val.get_type(&self)?;
-                    match val_ty {
-                        Type::CustomType(custom) => match self.type_data(&custom).kind {
-                            CustomTypeKind::NamedStruct(_) => Ok(()),
-                        },
-                        Type::Array(_, _) => Ok(()),
-                        _ => Err(ErrorKind::Null),
-                    }
-                }
-                Instr::Trunc(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::ZExt(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::SExt(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::FPTrunc(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::FPExt(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::FPToUI(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::FPToSI(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::UIToFP(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::SIToFP(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::PtrToInt(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::IntToPtr(instr, ty) => instr.cast_to(self, &ty).map(|_| ()),
-                Instr::BitCast(..) => Ok(()),
-                Instr::ShiftRightLogical(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::ShiftRightArithmetic(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::ShiftLeft(lhs, rhs) => match_types(&lhs, &rhs, &self).map(|_| ()),
-                Instr::GetGlobal(_) => Ok(()),
-            }
-        }
-    }
-
-    pub fn is_block_used(&self, block_v: BlockValue) -> bool {
-        unsafe {
-            let modules = self.modules.borrow();
-            let module = modules.get_unchecked(block_v.0.0.0);
-            let function = module.functions.get_unchecked(block_v.0.1);
-            let block = function.blocks.get_unchecked(block_v.1);
-
-            if block.instructions.len() > 0 || block.data.terminator.is_some() {
-                return true;
-            }
-
-            for other in &function.blocks {
-                if let Some(term) = &other.data.terminator {
-                    match term {
-                        TerminatorKind::Ret(_) => {}
-                        TerminatorKind::RetVoid => {}
-                        TerminatorKind::Br(other_val) => {
-                            if other_val == &block_v {
-                                return true;
-                            }
-                        }
-                        TerminatorKind::CondBr(_, then_other_v, else_other_v) => {
-                            if then_other_v == &block_v || else_other_v == &block_v {
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            false
-        }
-    }
-}
-
-impl InstructionValue {
-    pub fn with_location(self, block: &Block, location: DebugLocationValue) -> InstructionValue {
-        unsafe {
-            block.builder.add_instruction_location(&self, location);
-        }
-        self
-    }
-
-    pub fn maybe_location(self, block: &mut Block, location: Option<DebugLocationValue>) -> InstructionValue {
-        unsafe {
-            if let Some(location) = location {
-                block.builder.add_instruction_location(&self, location);
-            }
-        }
-        self
-    }
-
-    pub fn add_record(&self, block: &mut Block, record: InstructionDebugRecordData) {
-        unsafe {
-            block.builder.add_instruction_record(self, record);
-        }
-    }
-
-    pub(crate) fn get_type(&self, builder: &Builder) -> CompileResult<Type> {
-        use Instr::*;
-        unsafe {
-            match &builder.instr_data(self).kind {
-                Param(nth) => builder
-                    .function_data(&self.0.0)
-                    .params
-                    .get(*nth)
-                    .cloned()
-                    .ok_or(ErrorKind::Null),
-                Constant(c) => Ok(c.get_type()),
-                Add(lhs, rhs) => match_types(lhs, rhs, &builder),
-                FAdd(lhs, rhs) => match_types(lhs, rhs, &builder),
-                Sub(lhs, rhs) => match_types(lhs, rhs, &builder),
-                FSub(lhs, rhs) => match_types(lhs, rhs, &builder),
-                Mul(lhs, rhs) => match_types(lhs, rhs, &builder),
-                FMul(lhs, rhs) => match_types(lhs, rhs, &builder),
-                UDiv(lhs, rhs) => match_types(lhs, rhs, &builder),
-                SDiv(lhs, rhs) => match_types(lhs, rhs, &builder),
-                FDiv(lhs, rhs) => match_types(lhs, rhs, &builder),
-                URem(lhs, rhs) => match_types(lhs, rhs, &builder),
-                SRem(lhs, rhs) => match_types(lhs, rhs, &builder),
-                FRem(lhs, rhs) => match_types(lhs, rhs, &builder),
-                And(lhs, rhs) => match_types(lhs, rhs, &builder),
-                Or(lhs, rhs) => match_types(lhs, rhs, &builder),
-                XOr(lhs, rhs) => match_types(lhs, rhs, &builder),
-                ICmp(_, _, _) => Ok(Type::Bool),
-                FCmp(_, _, _) => Ok(Type::Bool),
-                FunctionCall(function_value, _) => Ok(builder.function_data(function_value).ret),
-                Phi(values) => values.first().ok_or(ErrorKind::Null).and_then(|v| v.get_type(&builder)),
-                Alloca(ty) => Ok(Type::Ptr(Box::new(ty.clone()))),
-                Load(_, ty) => Ok(ty.clone()),
-                Store(_, value) => value.get_type(builder),
-                ArrayAlloca(ty, _) => Ok(Type::Ptr(Box::new(ty.clone()))),
-                GetElemPtr(instr, _) => {
-                    let instr_ty = instr.get_type(builder)?;
-                    let Type::Ptr(inner_ty) = &instr_ty else {
-                        panic!("GetStructElemPtr on non-pointer! ({:?})", &instr_ty)
-                    };
-                    match *inner_ty.clone() {
-                        Type::Array(elem_ty, _) => Ok(Type::Ptr(Box::new(*elem_ty.clone()))),
-                        _ => Ok(instr_ty),
-                    }
-                }
-                GetStructElemPtr(instr, idx) => {
-                    let instr_ty = instr.get_type(builder)?;
-                    let Type::Ptr(inner_ty) = instr_ty else {
-                        panic!("GetStructElemPtr on non-pointer! ({:?})", &instr_ty)
-                    };
-                    let Type::CustomType(ty_value) = *inner_ty else {
-                        panic!("GetStructElemPtr on non-struct! ({:?})", &inner_ty)
-                    };
-                    let field_ty = match builder.type_data(&ty_value).kind {
-                        CustomTypeKind::NamedStruct(NamedStruct(_, fields)) => {
-                            fields.get_unchecked(*idx as usize).clone()
-                        }
-                    };
-                    Ok(Type::Ptr(Box::new(field_ty)))
-                }
-                ExtractValue(instr, idx) => {
-                    let instr_ty = instr.get_type(builder)?;
-                    Ok(match instr_ty {
-                        Type::CustomType(struct_ty) => {
-                            let data = builder.type_data(&struct_ty);
-                            match data.kind {
-                                CustomTypeKind::NamedStruct(named_struct) => {
-                                    named_struct.1.get(*idx as usize).unwrap().clone()
-                                }
-                            }
-                        }
-                        Type::Array(elem_ty, _) => *elem_ty.clone(),
-                        _ => return Err(ErrorKind::Null),
-                    })
-                }
-                Trunc(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                ZExt(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                SExt(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                FPTrunc(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                FPExt(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                FPToUI(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                FPToSI(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                UIToFP(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                SIToFP(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                PtrToInt(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                IntToPtr(instr, ty) => instr.cast_to(builder, ty).map(|_| ty.clone()),
-                BitCast(_, ty) => Ok(ty.clone()),
-                ShiftRightLogical(lhs, _) => lhs.get_type(builder),
-                ShiftRightArithmetic(lhs, _) => lhs.get_type(builder),
-                ShiftLeft(lhs, _) => lhs.get_type(builder),
-                GetGlobal(global_value) => {
-                    let constant = builder.get_global_initializer(*global_value);
-                    let kind = builder.get_const_kind(constant);
-                    Ok(kind.get_type())
-                }
-            }
-        }
-    }
-
-    fn cast_to(&self, builder: &Builder, ty: &Type) -> CompileResult<Instr> {
-        self.get_type(builder)?
-            .cast_instruction(*self, &ty)
-            .ok_or(ErrorKind::Null)
-    }
-}
--- a/reid-llvm-lib/src/compile.rs
+++ b/reid-llvm-lib/src/compile.rs
--- a/reid-llvm-lib/src/debug_information.rs
+++ b/reid-llvm-lib/src/debug_information.rs
@ -1,399 +0,0 @@
-use std::{
-    cell::{Ref, RefCell, RefMut},
-    rc::Rc,
-};
-
-use crate::builder::InstructionValue;
-
-/// Represents 1. the compilation context, 2. subprogram or 3. a lexical scope
-#[derive(Clone, Hash, PartialEq, Eq)]
-pub struct DebugScopeValue(pub Vec<usize>);
-
-#[derive(Clone, Hash, PartialEq, Eq)]
-pub struct DebugLocationValue(pub DebugScopeValue, pub usize);
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq)]
-pub struct DebugTypeValue(pub usize);
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq)]
-pub struct DebugMetadataValue(pub usize);
-
-#[derive(Debug, Clone)]
-pub struct DebugFileData {
-    pub name: String,
-    pub directory: String,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct DebugScopeHolder {
-    pub(crate) value: DebugScopeValue,
-    pub(crate) data: DebugScopeData,
-    pub(crate) inner_scopes: Vec<DebugScopeHolder>,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugMetadataHolder {
-    pub(crate) location: DebugLocation,
-    pub(crate) value: DebugMetadataValue,
-    pub(crate) data: DebugMetadata,
-}
-
-#[derive(Clone)]
-pub struct DebugTypeHolder {
-    pub(crate) value: DebugTypeValue,
-    pub(crate) data: DebugTypeData,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct DebugLocationHolder {
-    pub(crate) scope: DebugScopeValue,
-    pub(crate) value: DebugLocationValue,
-    pub(crate) location: DebugLocation,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugInformation {
-    pub file: DebugFileData,
-    scope: Rc<RefCell<DebugScopeHolder>>,
-    locations: Rc<RefCell<Vec<DebugLocationHolder>>>,
-    metadata: Rc<RefCell<Vec<DebugMetadataHolder>>>,
-    types: Rc<RefCell<Vec<DebugTypeHolder>>>,
-}
-
-impl DebugInformation {
-    pub fn from_file(file: DebugFileData) -> (DebugInformation, DebugScopeValue) {
-        let scope_value = DebugScopeValue(Vec::new());
-        (
-            DebugInformation {
-                file,
-                scope: Rc::new(RefCell::new(DebugScopeHolder {
-                    value: scope_value.clone(),
-                    inner_scopes: Vec::new(),
-                    data: DebugScopeData {
-                        parent: None,
-                        kind: DebugScopeKind::CodegenContext,
-                    },
-                })),
-                locations: Rc::new(RefCell::new(Vec::new())),
-                metadata: Rc::new(RefCell::new(Vec::new())),
-                types: Rc::new(RefCell::new(Vec::new())),
-            },
-            scope_value,
-        )
-    }
-
-    pub fn location(&self, scope_value: &DebugScopeValue, location: DebugLocation) -> DebugLocationValue {
-        let value = DebugLocationValue(scope_value.clone(), self.locations.borrow().len());
-        let location = DebugLocationHolder {
-            scope: scope_value.clone(),
-            value: value.clone(),
-            location,
-        };
-        self.locations.borrow_mut().push(location);
-        value
-    }
-
-    pub fn debug_type(&self, kind: DebugTypeData) -> DebugTypeValue {
-        let mut types = self.types.borrow_mut();
-        let value = DebugTypeValue(types.len());
-        types.push(DebugTypeHolder {
-            value: value.clone(),
-            data: kind,
-        });
-        value
-    }
-
-    pub fn metadata(&self, location: &DebugLocation, kind: DebugMetadata) -> DebugMetadataValue {
-        let mut metadata = self.metadata.borrow_mut();
-        let value = DebugMetadataValue(metadata.len());
-        metadata.push(DebugMetadataHolder {
-            location: location.clone(),
-            value: value.clone(),
-            data: kind,
-        });
-        value
-    }
-
-    pub fn subprogram(&self, parent: DebugScopeValue, kind: DebugSubprogramData) -> DebugScopeValue {
-        unsafe {
-            let mut outer_scope = RefMut::map(self.scope.borrow_mut(), |mut v| {
-                for i in &parent.0 {
-                    v = v.inner_scopes.get_unchecked_mut(*i);
-                }
-                v
-            });
-
-            let mut arr = parent.0.clone();
-            arr.push(outer_scope.inner_scopes.len());
-            let value = DebugScopeValue(arr);
-
-            outer_scope.inner_scopes.push(DebugScopeHolder {
-                value: value.clone(),
-                inner_scopes: Vec::new(),
-                data: DebugScopeData {
-                    parent: Some(parent.clone()),
-                    kind: DebugScopeKind::Subprogram(kind),
-                },
-            });
-            value
-        }
-    }
-    pub fn lexical_scope(&self, parent: &DebugScopeValue, data: DebugLexicalScope) -> DebugScopeValue {
-        unsafe {
-            let mut outer_scope = RefMut::map(self.scope.borrow_mut(), |mut v| {
-                for i in &parent.0 {
-                    v = v.inner_scopes.get_unchecked_mut(*i);
-                }
-                v
-            });
-
-            let mut arr = parent.0.clone();
-            arr.push(outer_scope.inner_scopes.len());
-            let value = DebugScopeValue(arr);
-
-            outer_scope.inner_scopes.push(DebugScopeHolder {
-                value: value.clone(),
-                inner_scopes: Vec::new(),
-                data: DebugScopeData {
-                    parent: Some(parent.clone()),
-                    kind: DebugScopeKind::LexicalScope(data),
-                },
-            });
-            value
-        }
-    }
-
-    pub fn get_metadata(&self, value: DebugMetadataValue) -> DebugMetadata {
-        unsafe { self.metadata.borrow().get_unchecked(value.0).data.clone() }
-    }
-
-    pub fn get_metadata_location(&self, value: DebugMetadataValue) -> DebugLocation {
-        unsafe { self.metadata.borrow().get_unchecked(value.0).location.clone() }
-    }
-
-    pub fn get_scope_data(&self, value: &DebugScopeValue) -> Option<DebugScopeData> {
-        let scope = Ref::filter_map(self.scope.borrow(), |v: &DebugScopeHolder| {
-            let mut opt = Some(v);
-            for i in &value.0 {
-                if let Some(inner) = opt {
-                    opt = inner.inner_scopes.get(*i);
-                }
-            }
-            opt
-        });
-
-        if let Ok(scope) = scope {
-            Some(scope.data.clone())
-        } else {
-            None
-        }
-    }
-
-    pub fn get_type_data(&self, value: DebugTypeValue) -> DebugTypeData {
-        unsafe { self.types.borrow().get_unchecked(value.0).data.clone() }
-    }
-
-    pub fn get_location(&self, value: &DebugLocationValue) -> DebugLocation {
-        unsafe { self.locations.borrow().get_unchecked(value.1).location.clone() }
-    }
-
-    pub fn get_metadatas(&self) -> Rc<RefCell<Vec<DebugMetadataHolder>>> {
-        self.metadata.clone()
-    }
-
-    pub(crate) fn get_scope(&self) -> Rc<RefCell<DebugScopeHolder>> {
-        self.scope.clone()
-    }
-
-    pub fn get_types(&self) -> Rc<RefCell<Vec<DebugTypeHolder>>> {
-        self.types.clone()
-    }
-
-    pub(crate) fn get_locations(&self) -> Rc<RefCell<Vec<DebugLocationHolder>>> {
-        self.locations.clone()
-    }
-}
-
-#[derive(Clone)]
-pub struct DebugLocation {
-    pub scope: DebugScopeValue,
-    pub pos: DebugPosition,
-}
-
-#[derive(Clone, Copy)]
-pub struct DebugPosition {
-    pub line: u32,
-    pub column: u32,
-}
-
-#[derive(Debug, Clone)]
-pub enum DebugMetadata {
-    ParamVar(DebugParamVariable),
-    LocalVar(DebugLocalVariable),
-    VarAssignment,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugParamVariable {
-    pub name: String,
-    /// the index (starting from 1) of this variable in the subprogram
-    /// parameters. arg_idx should not conflict with other parameters of the
-    /// same subprogram.
-    pub arg_idx: u32,
-    pub ty: DebugTypeValue,
-    /// If this variable will be referenced from its containing subprogram, and
-    /// will survive some optimizations.
-    pub always_preserve: bool,
-    pub flags: DwarfFlags,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugLocalVariable {
-    pub name: String,
-    pub ty: DebugTypeValue,
-    pub always_preserve: bool,
-    pub flags: DwarfFlags,
-}
-
-impl Default for DebugSubprogramOptionals {
-    fn default() -> Self {
-        Self {
-            scope_line: 0,
-            is_local: false,
-            is_definition: true,
-            is_optimized: false,
-            flags: DwarfFlags,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct DwarfFlags;
-
-#[derive(Clone)]
-pub enum DebugTypeData {
-    Basic(DebugBasicType),
-    Subprogram(DebugSubprogramType),
-    Pointer(DebugPointerType),
-    Array(DebugArrayType),
-    Struct(DebugStructType),
-}
-
-#[derive(Clone)]
-pub struct DebugBasicType {
-    pub name: String,
-    /// Size of the type.
-    pub size_bits: u64,
-    /// DWARF encoding code, e.g., dwarf::DW_ATE_float.
-    pub encoding: DwarfEncoding,
-    /// Optional DWARF attributes, e.g., DW_AT_endianity.
-    pub flags: DwarfFlags,
-}
-
-#[derive(Clone)]
-pub struct DebugArrayType {
-    pub size_bits: u64,
-    pub align_bits: u32,
-    pub element_type: DebugTypeValue,
-    pub length: u64,
-}
-
-#[derive(Clone)]
-pub struct DebugPointerType {
-    pub name: String,
-    pub pointee: DebugTypeValue,
-    pub size_bits: u64,
-}
-#[derive(Clone)]
-pub struct DebugStructType {
-    pub name: String,
-    pub scope: DebugScopeValue,
-    pub pos: Option<DebugPosition>,
-    pub size_bits: u64,
-    pub flags: DwarfFlags,
-    pub fields: Vec<DebugFieldType>,
-}
-
-#[derive(Clone)]
-pub struct DebugFieldType {
-    pub name: String,
-    pub scope: DebugScopeValue,
-    pub pos: Option<DebugPosition>,
-    pub size_bits: u64,
-    pub offset: u64,
-    pub flags: DwarfFlags,
-    pub ty: DebugTypeValue,
-}
-
-#[derive(Clone)]
-pub struct DebugSubprogramType {
-    pub parameters: Vec<DebugTypeValue>,
-    pub flags: DwarfFlags,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub enum DwarfEncoding {
-    Address = 1,
-    Boolean = 2,
-    Float = 4,
-    Signed = 5,
-    SignedChar = 6,
-    Unsigned = 7,
-    UnsignedChar = 8,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugScopeData {
-    pub parent: Option<DebugScopeValue>,
-    pub kind: DebugScopeKind,
-}
-
-#[derive(Debug, Clone)]
-pub enum DebugScopeKind {
-    CodegenContext,
-    LexicalScope(DebugLexicalScope),
-    Subprogram(DebugSubprogramData),
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugLexicalScope {
-    pub location: DebugLocation,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugSubprogramData {
-    /// Function name.
-    pub name: String,
-    pub outer_scope: DebugScopeValue,
-    /// Used for line number.
-    pub location: DebugLocation,
-    /// Function type.
-    pub ty: DebugTypeValue,
-    pub opts: DebugSubprogramOptionals,
-}
-
-#[derive(Debug, Clone)]
-pub struct DebugSubprogramOptionals {
-    /// Set to the beginning of the scope this starts
-    pub scope_line: u32,
-    pub is_local: bool,
-    pub is_definition: bool,
-    pub is_optimized: bool,
-    /// These flags are used to emit dwarf attributes. e.g. is this function
-    /// prototyped or not.
-    pub flags: DwarfFlags,
-}
-
-#[derive(Clone)]
-pub struct InstructionDebugRecordData {
-    pub scope: DebugScopeValue,
-    pub variable: DebugMetadataValue,
-    pub location: DebugLocation,
-    pub kind: DebugRecordKind,
-}
-
-#[derive(Clone, Copy)]
-pub enum DebugRecordKind {
-    Declare(InstructionValue),
-    Value(InstructionValue),
-}
--- a/reid-llvm-lib/src/fmt.rs
+++ b/reid-llvm-lib/src/fmt.rs
@ -1,594 +0,0 @@
-//! Debug implementations for relevant types
-
-use std::{
-    fmt::{Debug, Display, Write},
-    marker::PhantomData,
-};
-
-use crate::{
-    CmpPredicate, Context, Instr, InstructionData, TerminatorKind,
-    builder::*,
-    debug_information::{
-        DebugArrayType, DebugBasicType, DebugFieldType, DebugInformation, DebugLocalVariable, DebugLocation,
-        DebugLocationValue, DebugMetadata, DebugMetadataValue, DebugParamVariable, DebugPointerType, DebugPosition,
-        DebugRecordKind, DebugScopeValue, DebugStructType, DebugSubprogramType, DebugTypeData, DebugTypeHolder,
-        DebugTypeValue,
-    },
-    pad_adapter::PadAdapter,
-};
-
-impl Display for Context {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.builder, f)
-    }
-}
-
-impl Display for Builder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "Producer: {}", self.producer)?;
-        for module in self.modules.borrow().iter() {
-            if module.data.is_main {
-                write!(f, "main ")?;
-            }
-            writeln!(f, "{} ({:?}) {{", module.data.name, module.value)?;
-            for function in &module.functions {
-                let mut state = Default::default();
-                let mut inner = PadAdapter::wrap(f, &mut state);
-                function.builder_fmt(&mut inner, self, &module.debug_information)?;
-            }
-            writeln!(f, "}}")?;
-        }
-        Ok(())
-    }
-}
-
-impl FunctionHolder {
-    fn builder_fmt(
-        &self,
-        f: &mut impl std::fmt::Write,
-        builder: &Builder,
-        debug: &Option<DebugInformation>,
-    ) -> std::fmt::Result {
-        if self.data.flags.is_imported {
-            write!(f, "imported ")?;
-        }
-        if self.data.flags.is_extern {
-            write!(f, "extern ")?;
-        }
-        if self.data.flags.is_pub {
-            write!(f, "pub ")?;
-        }
-        if self.data.flags.is_main {
-            write!(f, "main ")?;
-        }
-        let params = self
-            .data
-            .params
-            .iter()
-            .map(|p| format!("{:?}", p))
-            .collect::<Vec<_>>()
-            .join(", ");
-        write!(f, "fn {}({}) -> {:?} ", self.data.name, params, self.data.ret)?;
-
-        writeln!(f, "{{")?;
-        let mut state = Default::default();
-        let mut inner = PadAdapter::wrap(f, &mut state);
-        writeln!(inner, "(Value = {:?}) ", self.value)?;
-        if let Some(debug) = &self.debug_info {
-            writeln!(inner, "(Debug = {:?})", debug)?;
-        }
-
-        for block in &self.blocks {
-            let mut state = Default::default();
-            let mut inner = PadAdapter::wrap(&mut inner, &mut state);
-            block.builder_fmt(&mut inner, builder, debug)?;
-        }
-
-        writeln!(f, "}}")?;
-        Ok(())
-    }
-}
-
-impl BlockHolder {
-    fn builder_fmt(
-        &self,
-        f: &mut impl std::fmt::Write,
-        builder: &Builder,
-        debug: &Option<DebugInformation>,
-    ) -> std::fmt::Result {
-        if self.data.deleted {
-            write!(f, "deleted ")?;
-        }
-        writeln!(f, "{} ({:?}):", self.data.name, self.value)?;
-
-        let mut state = Default::default();
-        let mut inner = PadAdapter::wrap(f, &mut state);
-
-        for instr in &self.instructions {
-            instr.builder_fmt(&mut inner, builder, debug)?;
-        }
-
-        if let Some(terminator) = &self.data.terminator {
-            terminator.builder_fmt(&mut inner, builder, debug)?;
-        }
-        if let Some(location) = &self.data.terminator_location {
-            writeln!(inner, "  ^  (At {}) ", debug.as_ref().unwrap().get_location(location))?;
-        }
-
-        Ok(())
-    }
-}
-
-impl InstructionHolder {
-    fn builder_fmt(
-        &self,
-        f: &mut impl std::fmt::Write,
-        _builder: &Builder,
-        debug: &Option<DebugInformation>,
-    ) -> std::fmt::Result {
-        if let Some(record) = &self.record {
-            let kind = match record.kind {
-                DebugRecordKind::Declare(instruction_value) => {
-                    format!("= {:?} (Assign)", instruction_value)
-                }
-                DebugRecordKind::Value(instruction_value) => {
-                    format!("= {:?} (Value)", instruction_value)
-                }
-            };
-
-            if let Some(debug) = debug {
-                writeln!(f, "  (Debug {} {})", record.variable.hr(debug), kind)?;
-            }
-        }
-        writeln!(f, "{:?} ({}) = {:?} ", self.value, self.name, self.data.kind)?;
-        if let Some(debug) = debug {
-            if let Some(location) = &self.data.location {
-                writeln!(f, "  ^  (At {}) ", debug.get_location(location))?;
-            }
-            if let Some(meta) = self.data.meta {
-                writeln!(f, "  ^  (Meta {}) ", meta.hr(debug))?;
-            }
-        }
-        writeln!(f)?;
-
-        Ok(())
-    }
-}
-
-impl TerminatorKind {
-    fn builder_fmt(
-        &self,
-        f: &mut impl std::fmt::Write,
-        _builder: &Builder,
-        _debug: &Option<DebugInformation>,
-    ) -> std::fmt::Result {
-        match self {
-            TerminatorKind::Ret(instr) => writeln!(f, "ret {:?}", instr),
-            TerminatorKind::RetVoid => writeln!(f, "ret void"),
-            TerminatorKind::Br(block) => writeln!(f, "br {:?}", block),
-            TerminatorKind::CondBr(instr, lhs, rhs) => {
-                writeln!(f, "condbr {:?}, {:?} or {:?}", instr, lhs, rhs)
-            }
-        }
-    }
-}
-
-impl DebugMetadataValue {
-    fn hr(&self, debug: &DebugInformation) -> String {
-        let kind = match debug.get_metadata(*self) {
-            DebugMetadata::ParamVar(DebugParamVariable { name, arg_idx, ty, .. }) => {
-                format!("param {} (idx {}) (type {:?}) ", name, arg_idx, ty)
-            }
-            DebugMetadata::LocalVar(DebugLocalVariable { name, ty, .. }) => {
-                format!("var {} (type {:?}) ", name, ty)
-            }
-            DebugMetadata::VarAssignment => todo!(),
-        };
-        format!("{} at {}", kind, debug.get_metadata_location(*self))
-    }
-}
-
-impl Display for DebugLocation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?} on scope {:?}", self.pos, self.scope)
-    }
-}
-
-impl Display for DebugPosition {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "line {}, col {}", self.line, self.column)
-    }
-}
-
-impl Debug for Builder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_list().entries(self.get_modules().borrow().iter());
-        Ok(())
-    }
-}
-
-pub struct PrintableModule<'ctx> {
-    pub phantom: PhantomData<&'ctx ()>,
-    pub module: ModuleHolder,
-}
-
-impl<'ctx> Debug for PrintableModule<'ctx> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        Debug::fmt(&self.module, f)
-    }
-}
-
-impl Debug for ModuleHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple(&format!("{}({:#?}) ", self.data.name, self.value))
-            .field(&self.functions)
-            // .field(&self.debug_information)
-            .finish()
-    }
-}
-
-impl Debug for FunctionHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple(&format!(
-            "{}({:?}) -> {:?} ",
-            self.data.name, self.data.params, self.data.ret
-        ))
-        .field(&self.blocks)
-        .finish()
-    }
-}
-
-impl Debug for BlockHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let deleted = if self.data.deleted { " (deleted)" } else { "" };
-        f.debug_tuple(&format!("{}[{:?}]{} ", &self.data.name, &self.value, deleted))
-            .field(&self.instructions)
-            .field(&self.data.terminator)
-            .field(&self.data.terminator_location)
-            .finish()
-    }
-}
-
-impl Debug for InstructionHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.value.fmt(f)?;
-        write!(f, " ({})", self.name)?;
-        f.write_str(" = ")?;
-        self.data.fmt(f)
-    }
-}
-
-impl Debug for InstructionData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.kind.fmt(f)?;
-        if let Some(location) = &self.location {
-            write!(f, " ({:?})", location)?;
-        }
-        Ok(())
-    }
-}
-
-impl Debug for ModuleValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "M[{:0>2}]", self.0)
-    }
-}
-
-impl Debug for FunctionValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "F[{:0>2}-{:0>2}]", &self.0.0, self.1)
-    }
-}
-
-impl Debug for BlockValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "B[{:0>2}-{:0>2}-{:0>2}]", &self.0.0.0, &self.0.1, self.1)
-    }
-}
-
-impl Debug for InstructionValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "%{}.{}.{}.{}", self.0.0.0.0, self.0.0.1, self.0.1, self.1)
-    }
-}
-
-// impl Debug for InstructionValue {
-//     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-//         write!(
-//             f,
-//             "I[{:0>2}-{:0>2}-{:0>2}-{:0>2}]",
-//             &self.0.0.0.0, &self.0.0.1, &self.0.1, self.1
-//         )
-//     }
-// }
-
-impl Debug for TypeValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Ty[{:0>2}-{:0>2}]", &self.0.0, self.1)
-    }
-}
-
-impl Debug for Instr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Instr::Param(nth) => fmt_call(f, &"Param", &nth),
-            Instr::Constant(c) => c.fmt(f),
-            Instr::Add(lhs, rhs) => fmt_binop(f, lhs, &"+", rhs),
-            Instr::FAdd(lhs, rhs) => fmt_binop(f, lhs, &"+", rhs),
-            Instr::Sub(lhs, rhs) => fmt_binop(f, lhs, &"-", rhs),
-            Instr::FSub(lhs, rhs) => fmt_binop(f, lhs, &"-", rhs),
-            Instr::Mul(lhs, rhs) => fmt_binop(f, lhs, &"*", rhs),
-            Instr::FMul(lhs, rhs) => fmt_binop(f, lhs, &"*", rhs),
-            Instr::UDiv(lhs, rhs) => fmt_binop(f, lhs, &"/", rhs),
-            Instr::SDiv(lhs, rhs) => fmt_binop(f, lhs, &"/", rhs),
-            Instr::FDiv(lhs, rhs) => fmt_binop(f, lhs, &"/", rhs),
-            Instr::URem(lhs, rhs) => fmt_binop(f, lhs, &"%", rhs),
-            Instr::SRem(lhs, rhs) => fmt_binop(f, lhs, &"%", rhs),
-            Instr::FRem(lhs, rhs) => fmt_binop(f, lhs, &"%", rhs),
-            Instr::And(lhs, rhs) => fmt_binop(f, lhs, &"&&", rhs),
-            Instr::Phi(val) => fmt_call(f, &"Phi", &val),
-            Instr::ICmp(cmp, lhs, rhs) => fmt_binop(f, lhs, cmp, rhs),
-            Instr::FCmp(cmp, lhs, rhs) => fmt_binop(f, lhs, cmp, rhs),
-            Instr::FunctionCall(fun, params) => fmt_call(f, fun, params),
-            Instr::Alloca(ty) => write!(f, "alloca<{:?}>", ty),
-            Instr::Load(val, ty) => write!(f, "load<{:?}>({:?})", ty, val),
-            Instr::Store(ptr, val) => write!(f, "store({:?} = {:?})", ptr, val),
-            Instr::ArrayAlloca(ty, instruction_value) => {
-                write!(f, "array_alloca<{:?}>({:?})", ty, instruction_value)
-            }
-            Instr::GetElemPtr(instruction_value, items) => fmt_index(
-                f,
-                instruction_value,
-                &items
-                    .iter()
-                    .map(|expr| format!("{:?}", expr))
-                    .collect::<Vec<_>>()
-                    .join(", "),
-            ),
-            Instr::GetStructElemPtr(instruction_value, index) => {
-                write!(f, "GEP(")?;
-                fmt_index(f, instruction_value, &index.to_string())?;
-                write!(f, ")")
-            }
-            Instr::ExtractValue(instruction_value, index) => fmt_index(f, instruction_value, &index.to_string()),
-            Instr::Trunc(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::ZExt(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::SExt(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::FPTrunc(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::FPExt(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::FPToUI(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::FPToSI(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::UIToFP(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::SIToFP(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::PtrToInt(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::IntToPtr(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::BitCast(instr_val, ty) => {
-                write!(f, "{:?} to {:?} ({})", instr_val, ty, self.default_name())
-            }
-            Instr::Or(lhs, rhs) => fmt_binop(f, lhs, &"||", rhs),
-            Instr::XOr(lhs, rhs) => fmt_binop(f, lhs, &"^", rhs),
-            Instr::ShiftRightLogical(lhs, rhs) => fmt_binop(f, lhs, &">>l", rhs),
-            Instr::ShiftRightArithmetic(lhs, rhs) => fmt_binop(f, lhs, &">>a", rhs),
-            Instr::ShiftLeft(lhs, rhs) => fmt_binop(f, lhs, &"<<", rhs),
-            Instr::GetGlobal(global_value) => write!(f, "global {:?}", global_value),
-        }
-    }
-}
-
-fn fmt_binop(
-    f: &mut std::fmt::Formatter<'_>,
-    lhs: &impl std::fmt::Debug,
-    op: &impl std::fmt::Debug,
-    rhs: &impl std::fmt::Debug,
-) -> std::fmt::Result {
-    lhs.fmt(f)?;
-    f.write_char(' ')?;
-    op.fmt(f)?;
-    f.write_char(' ')?;
-    rhs.fmt(f)
-}
-
-fn fmt_call(
-    f: &mut std::fmt::Formatter<'_>,
-    fun: &impl std::fmt::Debug,
-    params: &impl std::fmt::Debug,
-) -> std::fmt::Result {
-    fun.fmt(f)?;
-    f.write_char('(')?;
-    params.fmt(f)?;
-    f.write_char(')')
-}
-
-fn fmt_index(
-    f: &mut std::fmt::Formatter<'_>,
-    fun: &impl std::fmt::Debug,
-    params: &impl std::fmt::Debug,
-) -> std::fmt::Result {
-    fun.fmt(f)?;
-    f.write_char('[')?;
-    params.fmt(f)?;
-    f.write_char(']')
-}
-
-impl Debug for CmpPredicate {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::LT => write!(f, "<"),
-            Self::GT => write!(f, ">"),
-            Self::LE => write!(f, "<="),
-            Self::GE => write!(f, ">="),
-            Self::EQ => write!(f, "=="),
-            Self::NE => write!(f, "!="),
-        }
-    }
-}
-
-impl Debug for TerminatorKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Ret(val) => {
-                write!(f, "Ret ")?;
-                val.fmt(f)
-            }
-            Self::RetVoid => write!(f, "Void Ret"),
-            Self::Br(val) => {
-                write!(f, "Br ")?;
-                val.fmt(f)
-            }
-            Self::CondBr(cond, b1, b2) => {
-                write!(f, "CondBr ")?;
-                cond.fmt(f)?;
-                write!(f, " ? ")?;
-                b1.fmt(f)?;
-                write!(f, " : ")?;
-                b2.fmt(f)?;
-                Ok(())
-            }
-        }
-    }
-}
-
-impl Debug for DebugTypeHolder {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple(&format!("DebugTypeHolder {:?}", self.value))
-            .field(&self.data)
-            .finish()
-    }
-}
-
-impl Debug for DebugTypeData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            DebugTypeData::Basic(ty) => Debug::fmt(ty, f),
-            DebugTypeData::Subprogram(ty) => Debug::fmt(ty, f),
-            DebugTypeData::Pointer(ty) => Debug::fmt(ty, f),
-            DebugTypeData::Array(ty) => Debug::fmt(ty, f),
-            DebugTypeData::Struct(ty) => Debug::fmt(ty, f),
-        }
-    }
-}
-
-impl Debug for DebugBasicType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("BasicType")
-            .field(&self.name)
-            .field(&self.size_bits)
-            .field(&self.encoding)
-            .field(&self.flags)
-            .finish()
-    }
-}
-
-impl Debug for DebugStructType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Struct")
-            .field("name", &self.name)
-            .field("scope", &self.scope)
-            .field("pos", &self.pos)
-            .field("size_bit", &self.size_bits)
-            .field("flags", &self.flags)
-            .field("elements", &self.fields)
-            .finish()
-    }
-}
-
-impl Debug for DebugFieldType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct(&format!("Field({})", self.name))
-            .field("scope", &self.scope)
-            .field("pos", &self.pos)
-            .field("size_bits", &self.size_bits)
-            .field("offset", &self.offset)
-            .field("flags", &self.flags)
-            .field("ty", &self.ty)
-            .finish()
-    }
-}
-
-impl Debug for DebugSubprogramType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple("Subprogram")
-            .field(&self.parameters)
-            .field(&self.flags)
-            .finish()
-    }
-}
-
-impl Debug for DebugPointerType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_tuple(&format!("Pointer<{:?}>({})", self.pointee, self.name))
-            .field(&self.size_bits)
-            .finish()
-    }
-}
-
-impl Debug for DebugArrayType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct(&format!("Array<{:?}>[{}]", self.element_type, self.length))
-            .field("size_bits", &self.size_bits)
-            .field("align_bits", &self.align_bits)
-            .finish()
-    }
-}
-
-impl Debug for DebugMetadataValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Meta[{}]", self.0)
-    }
-}
-
-impl Debug for DebugScopeValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Scope[{}]",
-            self.0.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(", ")
-        )
-    }
-}
-
-impl Debug for DebugTypeValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Type[{}]", self.0)
-    }
-}
-
-impl Debug for DebugLocationValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Value[{:?}][{}]", self.0, self.1)
-    }
-}
-
-impl Debug for DebugLocation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?} on scope {:?}", self.pos, self.scope)
-    }
-}
-
-impl Debug for DebugPosition {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "ln {}, col {}", self.line, self.column)
-    }
-}
--- a/reid-llvm-lib/src/lib.rs
+++ b/reid-llvm-lib/src/lib.rs
@ -1,688 +0,0 @@
-//! Reid LLVM Lib is an ergonomic Rust'y API which is used to produce a
-//! Low-Level IR (LLIR) using [`Context`] and [`Builder`]. This Builder can then
-//! be used at the end to compile said LLIR into LLVM IR.
-
-use std::{fmt::Debug, marker::PhantomData};
-
-use builder::{BlockValue, Builder, FunctionValue, InstructionValue, ModuleValue, TypeValue};
-use debug_information::{DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue};
-use fmt::PrintableModule;
-
-use crate::{
-    builder::{ConstantValue, GlobalValue},
-    debug_information::DebugScopeValue,
-};
-
-pub mod builder;
-pub mod compile;
-pub mod debug_information;
-mod fmt;
-mod pad_adapter;
-mod util;
-
-#[derive(thiserror::Error, Debug, Clone, PartialEq, PartialOrd)]
-pub enum ErrorKind {
-    #[error("NULL error, should never occur!")]
-    Null,
-}
-
-pub type CompileResult<T> = Result<T, ErrorKind>;
-
-#[derive(Debug)]
-pub struct Context {
-    builder: Builder,
-}
-
-impl Context {
-    pub fn new<T: Into<String>>(producer: T) -> Context {
-        Context {
-            builder: Builder::new(producer.into()),
-        }
-    }
-
-    pub fn module<'ctx>(&'ctx self, name: &str, main: bool) -> Module<'ctx> {
-        let value = self.builder.add_module(ModuleData {
-            name: name.to_owned(),
-            is_main: main,
-        });
-        Module {
-            phantom: PhantomData,
-            builder: self.builder.clone(),
-            value,
-            debug_info: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Hash)]
-pub struct ModuleData {
-    name: String,
-    is_main: bool,
-}
-
-#[derive(Clone)]
-pub struct Module<'ctx> {
-    phantom: PhantomData<&'ctx ()>,
-    builder: Builder,
-    value: ModuleValue,
-    debug_info: Option<DebugInformation>,
-}
-
-impl<'ctx> Module<'ctx> {
-    pub fn function(
-        &self,
-        name: &str,
-        linkage: Option<String>,
-        ret: Type,
-        params: Vec<Type>,
-        flags: FunctionFlags,
-    ) -> Function<'ctx> {
-        unsafe {
-            Function {
-                phantom: PhantomData,
-                builder: self.builder.clone(),
-                value: self.builder.add_function(
-                    &self.value,
-                    FunctionData {
-                        name: name.to_owned(),
-                        linkage_name: linkage,
-                        ret,
-                        params,
-                        flags,
-                    },
-                ),
-            }
-        }
-    }
-
-    pub fn custom_type(&self, ty: CustomTypeKind) -> TypeValue {
-        unsafe {
-            let (name, kind) = match &ty {
-                CustomTypeKind::NamedStruct(NamedStruct(name, _)) => (name.clone(), ty),
-            };
-            self.builder.add_type(&self.value, TypeData { name, kind })
-        }
-    }
-
-    pub fn value(&self) -> ModuleValue {
-        self.value
-    }
-
-    pub fn as_printable(&self) -> PrintableModule<'ctx> {
-        PrintableModule {
-            phantom: PhantomData,
-            module: self.builder.find_module(self.value),
-        }
-    }
-
-    pub fn create_debug_info(&mut self, file: DebugFileData) -> (DebugInformation, DebugScopeValue) {
-        let (debug_info, scope_value) = DebugInformation::from_file(file);
-        self.debug_info = Some(debug_info.clone());
-        (debug_info, scope_value)
-    }
-
-    pub fn get_debug_info(&self) -> &Option<DebugInformation> {
-        &self.debug_info
-    }
-
-    pub fn add_constant(&self, constant: ConstValueKind) -> ConstantValue {
-        unsafe { self.builder.build_constant(self.value, constant) }
-    }
-
-    pub fn add_global<T: Into<String>>(&self, name: T, constant: ConstantValue) -> GlobalValue {
-        unsafe { self.builder.add_global(self.value, name.into(), constant) }
-    }
-}
-
-impl<'ctx> Drop for Module<'ctx> {
-    fn drop(&mut self) {
-        if let Some(debug_info) = self.debug_info.take() {
-            self.builder.set_debug_information(&self.value, debug_info);
-        }
-    }
-}
-
-#[derive(Debug, Clone, Hash)]
-pub struct FunctionData {
-    name: String,
-    linkage_name: Option<String>,
-    ret: Type,
-    params: Vec<Type>,
-    flags: FunctionFlags,
-}
-
-#[derive(Debug, Clone, Copy, Hash)]
-pub struct FunctionFlags {
-    /// True in the destination module of the import, false in the source module.
-    pub is_extern: bool,
-    /// Whether this function is the main function of the module, that should be
-    /// executed (and linked externally also).
-    pub is_main: bool,
-    /// Whether this function should be available externally always.
-    pub is_pub: bool,
-    /// If this function is an imported function (either in the source or
-    /// destination module)
-    pub is_imported: bool,
-    /// Whether this function should add "alwaysinline"-attribute.
-    pub inline: bool,
-}
-
-impl Default for FunctionFlags {
-    fn default() -> FunctionFlags {
-        FunctionFlags {
-            is_extern: false,
-            is_main: false,
-            is_pub: false,
-            is_imported: false,
-            inline: false,
-        }
-    }
-}
-
-pub struct Function<'ctx> {
-    phantom: PhantomData<&'ctx ()>,
-    builder: Builder,
-    value: FunctionValue,
-}
-
-impl<'ctx> Function<'ctx> {
-    pub fn block(&self, name: &str) -> Block<'ctx> {
-        unsafe {
-            Block {
-                phantom: PhantomData,
-                builder: self.builder.clone(),
-                value: self.builder.add_block(
-                    &self.value,
-                    BlockData {
-                        name: name.to_owned(),
-                        terminator: None,
-                        terminator_location: None,
-                        deleted: false,
-                    },
-                ),
-            }
-        }
-    }
-
-    pub fn set_debug(&self, subprogram: DebugScopeValue) {
-        unsafe {
-            self.builder.set_debug_subprogram(&self.value, subprogram);
-        }
-    }
-
-    pub fn value(&self) -> FunctionValue {
-        self.value
-    }
-}
-
-#[derive(Debug, Clone, Hash)]
-pub struct BlockData {
-    name: String,
-    terminator: Option<TerminatorKind>,
-    terminator_location: Option<DebugLocationValue>,
-    deleted: bool,
-}
-
-#[derive(Clone)]
-pub struct Block<'builder> {
-    phantom: PhantomData<&'builder ()>,
-    builder: Builder,
-    value: BlockValue,
-}
-
-impl Instr {
-    pub fn default_name(&self) -> &str {
-        match self {
-            Instr::Param(_) => "param",
-            Instr::Constant(_) => "const1",
-            Instr::Add(..) => "add",
-            Instr::FAdd(..) => "fadd",
-            Instr::Sub(..) => "sub",
-            Instr::FSub(..) => "fsub",
-            Instr::Mul(..) => "mul",
-            Instr::FMul(..) => "fmul",
-            Instr::UDiv(..) => "udiv",
-            Instr::SDiv(..) => "sdiv",
-            Instr::FDiv(..) => "fdiv",
-            Instr::URem(..) => "urem",
-            Instr::SRem(..) => "srem",
-            Instr::FRem(..) => "frem",
-            Instr::And(..) => "and",
-            Instr::Phi(_) => "phi",
-            Instr::Alloca(_) => "alloca",
-            Instr::Load(_, _) => "load",
-            Instr::Store(..) => "store",
-            Instr::ArrayAlloca(_, _) => "arrayalloca",
-            Instr::GetElemPtr(..) => "getelemptr",
-            Instr::GetStructElemPtr(..) => "getstructelemptr",
-            Instr::ExtractValue(..) => "extractvalue",
-            Instr::ICmp(..) => "icmp",
-            Instr::FunctionCall(..) => "call",
-            Instr::FCmp(_, _, _) => "fcmp",
-            Instr::Trunc(_, _) => "trunc",
-            Instr::ZExt(_, _) => "zext",
-            Instr::SExt(_, _) => "sext",
-            Instr::FPTrunc(_, _) => "fptrunc",
-            Instr::FPExt(_, _) => "pfext",
-            Instr::FPToUI(_, _) => "fptoui",
-            Instr::FPToSI(_, _) => "fptosi",
-            Instr::UIToFP(_, _) => "uitofp",
-            Instr::SIToFP(_, _) => "sitofp",
-            Instr::PtrToInt(_, _) => "ptrtoint",
-            Instr::IntToPtr(_, _) => "inttoptr",
-            Instr::BitCast(_, _) => "bitcast",
-            Instr::Or(..) => "or",
-            Instr::XOr(..) => "xor",
-            Instr::ShiftRightLogical(..) => "lshr",
-            Instr::ShiftRightArithmetic(..) => "ashr",
-            Instr::ShiftLeft(..) => "shl",
-            Instr::GetGlobal(..) => "global",
-        }
-    }
-}
-
-impl<'builder> Block<'builder> {
-    pub fn build_named<T: Into<String>>(&mut self, name: T, instruction: Instr) -> CompileResult<InstructionValue> {
-        unsafe {
-            self.builder.add_instruction(
-                &self.value,
-                InstructionData {
-                    kind: instruction,
-                    location: None,
-                    meta: None,
-                },
-                name.into(),
-            )
-        }
-    }
-
-    pub fn build(&mut self, instruction: Instr) -> CompileResult<InstructionValue> {
-        unsafe {
-            let name = instruction.default_name().to_owned();
-            self.builder.add_instruction(
-                &self.value,
-                InstructionData {
-                    kind: instruction,
-                    location: None,
-                    meta: None,
-                },
-                name,
-            )
-        }
-    }
-
-    pub fn find_function(&mut self, name: &String) -> Option<FunctionValue> {
-        unsafe { self.builder.find_function(self.value.0.0, name) }
-    }
-
-    pub fn set_instr_location(&self, instruction: InstructionValue, location: DebugLocationValue) {
-        unsafe {
-            self.builder.add_instruction_location(&instruction, location);
-        }
-    }
-
-    pub fn set_instr_metadata(&self, instruction: InstructionValue, location: DebugMetadataValue) {
-        unsafe {
-            self.builder.add_instruction_metadata(&instruction, location);
-        }
-    }
-
-    pub fn terminate(&mut self, instruction: TerminatorKind) -> CompileResult<()> {
-        unsafe { self.builder.terminate(&self.value, instruction) }
-    }
-
-    pub fn set_terminator_location(&mut self, location: DebugLocationValue) -> CompileResult<()> {
-        unsafe { self.builder.set_terminator_location(&self.value, location) }
-    }
-
-    /// Delete block if it is unused. Return true if deleted, false if not.
-    pub fn delete_if_unused(&mut self) -> CompileResult<bool> {
-        unsafe {
-            if !self.builder.is_block_used(self.value()) {
-                self.builder.delete_block(&self.value)?;
-                Ok(true)
-            } else {
-                Ok(false)
-            }
-        }
-    }
-
-    pub fn value(&self) -> BlockValue {
-        self.value
-    }
-}
-
-#[derive(Clone)]
-pub struct InstructionData {
-    kind: Instr,
-    location: Option<DebugLocationValue>,
-    meta: Option<DebugMetadataValue>,
-}
-
-#[derive(Clone, Copy, Hash)]
-pub enum CmpPredicate {
-    LT,
-    LE,
-    GT,
-    GE,
-    EQ,
-    NE,
-}
-
-/// https://llvm.org/docs/LangRef.html#instruction-reference
-#[derive(Clone)]
-pub enum Instr {
-    Param(usize),
-    Constant(ConstValueKind),
-    GetGlobal(GlobalValue),
-
-    /// Add two integers
-    Add(InstructionValue, InstructionValue),
-    /// Add two floats
-    FAdd(InstructionValue, InstructionValue),
-    /// Subtract two integers
-    Sub(InstructionValue, InstructionValue),
-    /// Subtract two floats
-    FSub(InstructionValue, InstructionValue),
-    /// Multiply two integers
-    Mul(InstructionValue, InstructionValue),
-    /// Multiply two floats
-    FMul(InstructionValue, InstructionValue),
-    /// Divide two unsigned integers
-    UDiv(InstructionValue, InstructionValue),
-    /// Divide two signed integers
-    SDiv(InstructionValue, InstructionValue),
-    /// Divide two floats
-    FDiv(InstructionValue, InstructionValue),
-    /// Get the remainder from two unsigned integers
-    URem(InstructionValue, InstructionValue),
-    /// Get the remainder from two signed integers
-    SRem(InstructionValue, InstructionValue),
-    /// Get the remainder from two floats
-    FRem(InstructionValue, InstructionValue),
-
-    And(InstructionValue, InstructionValue),
-    Or(InstructionValue, InstructionValue),
-    XOr(InstructionValue, InstructionValue),
-    ShiftRightLogical(InstructionValue, InstructionValue),
-    ShiftRightArithmetic(InstructionValue, InstructionValue),
-    ShiftLeft(InstructionValue, InstructionValue),
-
-    Phi(Vec<InstructionValue>),
-
-    Alloca(Type),
-    Load(InstructionValue, Type),
-    Store(InstructionValue, InstructionValue),
-    ArrayAlloca(Type, InstructionValue),
-    GetElemPtr(InstructionValue, Vec<InstructionValue>),
-    GetStructElemPtr(InstructionValue, u32),
-    ExtractValue(InstructionValue, u32),
-
-    /// Integer Comparison
-    ICmp(CmpPredicate, InstructionValue, InstructionValue),
-    /// FLoat Comparison
-    FCmp(CmpPredicate, InstructionValue, InstructionValue),
-
-    /// The `trunc` instruction truncates the high order bits in value and
-    /// converts the remaining bits to ty2. Since the source size must be larger
-    /// than the destination size, `trunc` cannot be a no-op cast. It will
-    /// always truncate bits.
-    Trunc(InstructionValue, Type),
-    /// The `zext` fills the high order bits of the value with zero bits until
-    /// it reaches the size of the destination type, ty2.
-    ZExt(InstructionValue, Type),
-    /// The `sext` instruction performs a sign extension by copying the sign bit
-    /// (highest order bit) of the value until it reaches the bit size of the
-    /// type ty2.
-    SExt(InstructionValue, Type),
-    /// The `fptrunc` instruction casts a value from a larger floating-point
-    /// type to a smaller floating-point type.
-    FPTrunc(InstructionValue, Type),
-    /// The `fpext` instruction extends the value from a smaller floating-point
-    /// type to a larger floating-point type.
-    FPExt(InstructionValue, Type),
-    /// The `fptoui` instruction takes a value to cast, which must be a scalar
-    /// or vector floating-point value, and a type to cast it to ty2, which must
-    /// be an integer type.
-    FPToUI(InstructionValue, Type),
-    /// The `fptosi` instruction takes a value to cast, which must be a scalar
-    /// or vector floating-point value, and a type to cast it to ty2, which must
-    /// be an integer type.
-    FPToSI(InstructionValue, Type),
-    /// The `uitofp` instruction takes a value to cast, which must be a scalar
-    /// or vector integer value, and a type to cast it to ty2, which must be an
-    /// floating-point type.
-    UIToFP(InstructionValue, Type),
-    /// The `sitofp` instruction takes a value to cast, which must be a scalar
-    /// or vector integer value, and a type to cast it to ty2, which must be an
-    /// floating-point type
-    SIToFP(InstructionValue, Type),
-    /// The `ptrtoint` instruction converts value to integer type ty2 by
-    /// interpreting the all pointer representation bits as an integer
-    /// (equivalent to a bitcast) and either truncating or zero extending that
-    /// value to the size of the integer type.
-    PtrToInt(InstructionValue, Type),
-    /// The `inttoptr` instruction converts value to type ty2 by applying either
-    /// a zero extension or a truncation depending on the size of the integer
-    /// value.
-    IntToPtr(InstructionValue, Type),
-    /// The `bitcast` instruction converts value to type ty2. It is always a
-    /// no-op cast because no bits change with this conversion.
-    BitCast(InstructionValue, Type),
-
-    FunctionCall(FunctionValue, Vec<InstructionValue>),
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum Type {
-    I8,
-    I16,
-    I32,
-    I64,
-    I128,
-    U8,
-    U16,
-    U32,
-    U64,
-    U128,
-    F16,
-    F32B,
-    F32,
-    F64,
-    F80,
-    F128,
-    F128PPC,
-    Bool,
-    Void,
-    CustomType(TypeValue),
-    Array(Box<Type>, u64),
-    Ptr(Box<Type>),
-}
-
-#[derive(Debug, Clone)]
-pub enum ConstValueKind {
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    I128(i128),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    U128(u128),
-    Bool(bool),
-    Str(String),
-    F16(f32),
-    F32B(f32),
-    F32(f32),
-    F64(f64),
-    F80(f64),
-    F128(f64),
-    F128PPC(f64),
-    Array(Vec<ConstantValue>, Type),
-}
-
-#[derive(Clone, Hash)]
-pub enum TerminatorKind {
-    Ret(InstructionValue),
-    RetVoid,
-    Br(BlockValue),
-    CondBr(InstructionValue, BlockValue, BlockValue),
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub struct TypeData {
-    name: String,
-    kind: CustomTypeKind,
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum CustomTypeKind {
-    NamedStruct(NamedStruct),
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub struct NamedStruct(pub String, pub Vec<Type>);
-
-impl ConstValueKind {
-    pub fn get_type(&self) -> Type {
-        use Type::*;
-        match self {
-            ConstValueKind::I8(_) => I8,
-            ConstValueKind::I16(_) => I16,
-            ConstValueKind::I32(_) => I32,
-            ConstValueKind::I64(_) => I64,
-            ConstValueKind::I128(_) => I128,
-            ConstValueKind::U8(_) => U8,
-            ConstValueKind::U16(_) => U16,
-            ConstValueKind::U32(_) => U32,
-            ConstValueKind::U64(_) => U64,
-            ConstValueKind::U128(_) => U128,
-            ConstValueKind::Str(_) => Type::Ptr(Box::new(U8)),
-            ConstValueKind::Bool(_) => Bool,
-            ConstValueKind::F16(_) => F16,
-            ConstValueKind::F32B(_) => F32B,
-            ConstValueKind::F32(_) => F32,
-            ConstValueKind::F64(_) => F64,
-            ConstValueKind::F80(_) => F80,
-            ConstValueKind::F128(_) => F128,
-            ConstValueKind::F128PPC(_) => F128PPC,
-            ConstValueKind::Array(vals, ty) => Type::Array(Box::new(ty.clone()), vals.len() as u64),
-        }
-    }
-}
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
-pub enum TypeCategory {
-    SignedInteger,
-    UnsignedInteger,
-    Void,
-    Real,
-    Ptr,
-    CustomType,
-    Array,
-}
-
-impl TypeCategory {
-    pub fn comparable(&self) -> bool {
-        match self {
-            TypeCategory::SignedInteger => true,
-            TypeCategory::UnsignedInteger => true,
-            TypeCategory::Real => true,
-            _ => false,
-        }
-    }
-
-    pub fn signed(&self) -> bool {
-        match self {
-            TypeCategory::SignedInteger => true,
-            _ => false,
-        }
-    }
-
-    pub fn integer(&self) -> bool {
-        match self {
-            TypeCategory::SignedInteger => true,
-            TypeCategory::UnsignedInteger => true,
-            _ => false,
-        }
-    }
-}
-
-impl Type {
-    pub fn category(&self) -> TypeCategory {
-        match self {
-            Type::I8 | Type::I16 | Type::I32 | Type::I64 | Type::I128 => TypeCategory::SignedInteger,
-            Type::U8 | Type::U16 | Type::U32 | Type::U64 | Type::U128 => TypeCategory::UnsignedInteger,
-            Type::F16 | Type::F32B | Type::F32 | Type::F64 | Type::F80 | Type::F128 | Type::F128PPC => {
-                TypeCategory::Real
-            }
-            Type::Bool => TypeCategory::UnsignedInteger,
-            Type::Void => TypeCategory::Void,
-            Type::CustomType(_) => TypeCategory::CustomType,
-            Type::Array(_, _) => TypeCategory::Array,
-            Type::Ptr(_) => TypeCategory::Ptr,
-        }
-    }
-
-    pub fn cast_instruction(&self, value: InstructionValue, other: &Type) -> Option<Instr> {
-        use Type::*;
-        match (self, other) {
-            (I8, I16 | I32 | I64 | I128) => Some(Instr::SExt(value, other.clone())),
-            (I16, I32 | I64 | I128) => Some(Instr::SExt(value, other.clone())),
-            (I32, I64 | I128) => Some(Instr::SExt(value, other.clone())),
-            (I64, I128) => Some(Instr::SExt(value, other.clone())),
-            (I128 | U128, I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
-            (I64 | U64, I32 | U32 | I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
-            (I32 | U32, I16 | U16 | I8 | U8) => Some(Instr::Trunc(value, other.clone())),
-            (I16 | U16, I8 | U8) => Some(Instr::Trunc(value, other.clone())),
-            (U8 | I8, U8 | I8 | U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => {
-                Some(Instr::ZExt(value, other.clone()))
-            }
-            (U16 | I16, U16 | I16 | U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
-            (U32 | I32, U32 | I32 | U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
-            (U64 | I64, U64 | I64 | U128 | I128) => Some(Instr::ZExt(value, other.clone())),
-            (U128 | I128, U128 | I128) => Some(Instr::ZExt(value, other.clone())),
-            (U8 | U16 | U32 | U64 | U128, F16 | F32 | F32B | F64 | F80 | F128 | F128PPC) => {
-                Some(Instr::UIToFP(value, other.clone()))
-            }
-            (I8 | I16 | I32 | I64 | I128, F16 | F32 | F32B | F64 | F80 | F128 | F128PPC) => {
-                Some(Instr::SIToFP(value, other.clone()))
-            }
-            (F16 | F32 | F32B | F64 | F80 | F128 | F128PPC, U8 | U16 | U32 | U64 | U128) => {
-                Some(Instr::FPToUI(value, other.clone()))
-            }
-            (F16 | F32 | F32B | F64 | F80 | F128 | F128PPC, I8 | I16 | I32 | I64 | I128) => {
-                Some(Instr::FPToSI(value, other.clone()))
-            }
-            (I128 | U128 | I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8, Ptr(_)) => {
-                Some(Instr::IntToPtr(value, other.clone()))
-            }
-            (Ptr(_), I128 | U128 | I64 | U64 | I32 | U32 | I16 | U16 | I8 | U8) => {
-                Some(Instr::PtrToInt(value, other.clone()))
-            }
-            (F16, F32 | F32B | F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
-            (F32 | F32B, F64 | F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
-            (F64, F80 | F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
-            (F80, F128 | F128PPC) => Some(Instr::FPExt(value, other.clone())),
-            (F128PPC | F128, F80 | F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
-            (F80, F64 | F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
-            (F64, F32B | F32 | F16) => Some(Instr::FPTrunc(value, other.clone())),
-            (F32B | F32, F16) => Some(Instr::FPTrunc(value, other.clone())),
-            _ => None,
-        }
-    }
-}
-
-impl TerminatorKind {
-    pub(crate) fn get_type(&self, builder: &Builder) -> CompileResult<Type> {
-        use TerminatorKind::*;
-        match self {
-            Ret(instr_val) => instr_val.get_type(builder),
-            RetVoid => Ok(Type::Void),
-            Br(_) => Ok(Type::Void),
-            CondBr(_, _, _) => Ok(Type::Void),
-        }
-    }
-}
--- a/reid-llvm-lib/src/pad_adapter.rs
+++ b/reid-llvm-lib/src/pad_adapter.rs
@ -1,69 +0,0 @@
-//! Copied from
-//! https://github.com/rust-lang/rust/blob/6b3ae3f6e45a33c2d95fa0362c9b2593e567fd34/library/core/src/fmt/builders.rs#L102
-
-// Copyright (c) The Rust Project Contributors
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-use std::fmt;
-
-pub struct PadAdapter<'buf, 'state> {
-    buf: &'buf mut (dyn fmt::Write + 'buf),
-    state: &'state mut PadAdapterState,
-}
-
-pub struct PadAdapterState {
-    on_newline: bool,
-}
-
-impl Default for PadAdapterState {
-    fn default() -> Self {
-        PadAdapterState { on_newline: true }
-    }
-}
-
-impl<'buf, 'state> PadAdapter<'buf, 'state> {
-    pub fn wrap<'slot, 'fmt: 'buf + 'slot>(
-        fmt: &'buf mut (dyn fmt::Write + 'buf),
-        state: &'state mut PadAdapterState,
-    ) -> Self {
-        PadAdapter { buf: fmt, state }
-    }
-}
-
-impl fmt::Write for PadAdapter<'_, '_> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for s in s.split_inclusive('\n') {
-            if self.state.on_newline {
-                self.buf.write_str("    ")?;
-            }
-            self.state.on_newline = s.ends_with('\n');
-            self.buf.write_str(s)?;
-        }
-        Ok(())
-    }
-
-    fn write_char(&mut self, c: char) -> fmt::Result {
-        if self.state.on_newline {
-            self.buf.write_str("    ")?;
-        }
-        self.state.on_newline = c == '\n';
-        self.buf.write_char(c)
-    }
-}
--- a/reid-llvm-lib/src/util.rs
+++ b/reid-llvm-lib/src/util.rs
@ -1,132 +0,0 @@
-use std::{
-    ffi::{CStr, CString, c_char},
-    ptr::null_mut,
-    string::FromUtf8Error,
-};
-
-use llvm_sys::{
-    core::{
-        LLVMCreateMemoryBufferWithMemoryRange, LLVMDisposeMemoryBuffer, LLVMGetBufferSize,
-        LLVMGetBufferStart,
-    },
-    error::LLVMDisposeErrorMessage,
-    prelude::LLVMMemoryBufferRef,
-};
-
-use crate::{
-    CompileResult, ErrorKind, Type,
-    builder::{Builder, InstructionValue},
-};
-
-pub fn into_cstring<T: Into<String>>(value: T) -> CString {
-    let string = value.into();
-    unsafe { CString::from_vec_with_nul_unchecked((string + "\0").into_bytes()) }
-}
-
-pub fn from_cstring(pointer: *mut c_char) -> Option<String> {
-    if pointer.is_null() {
-        None
-    } else {
-        unsafe { CStr::from_ptr(pointer).to_str().ok().map(|s| s.to_owned()) }
-    }
-}
-
-fn cstring_to_err(value: *mut c_char) -> Result<(), String> {
-    from_cstring(value)
-        .filter(|s| !s.is_empty())
-        .map_or(Ok(()), |s| Err(s))
-}
-
-/// Utility struct for LLVM's Error Messages, which need to be disposed
-/// manually.
-pub struct ErrorMessageHolder(*mut c_char);
-
-impl ErrorMessageHolder {
-    pub fn null() -> Self {
-        ErrorMessageHolder(null_mut())
-    }
-
-    pub fn borrow_mut(&mut self) -> *mut *mut c_char {
-        &mut self.0
-    }
-
-    pub fn into_result(&self) -> Result<(), String> {
-        cstring_to_err(self.0)
-    }
-}
-
-impl Drop for ErrorMessageHolder {
-    fn drop(&mut self) {
-        unsafe {
-            if !self.0.is_null() {
-                LLVMDisposeErrorMessage(self.0);
-            }
-        }
-    }
-}
-
-/// Utility for creating and handling LLVM MemoryBuffers, needed for printing
-/// out ASM and .o -files without relying on LLVM's own API.
-pub struct MemoryBufferHolder {
-    pub buffer: LLVMMemoryBufferRef,
-}
-
-impl MemoryBufferHolder {
-    pub fn empty(name: &str) -> MemoryBufferHolder {
-        let array = [0i8; 0];
-        unsafe {
-            let buffer = LLVMCreateMemoryBufferWithMemoryRange(
-                array.as_ptr(),
-                array.len(),
-                into_cstring(name).as_ptr(),
-                0,
-            );
-            MemoryBufferHolder { buffer }
-        }
-    }
-
-    pub fn as_buffer(&self) -> Vec<u8> {
-        unsafe {
-            let start = LLVMGetBufferStart(self.buffer);
-            let size = LLVMGetBufferSize(self.buffer);
-
-            let mut buff = Vec::with_capacity(size);
-            for i in 0..size {
-                buff.push(*start.add(i) as u8);
-            }
-            buff
-        }
-    }
-
-    pub fn as_string(&self) -> Result<String, FromUtf8Error> {
-        String::from_utf8(self.as_buffer())
-    }
-}
-
-impl Drop for MemoryBufferHolder {
-    fn drop(&mut self) {
-        unsafe {
-            LLVMDisposeMemoryBuffer(self.buffer);
-        }
-    }
-}
-
-/// Make sure types for given instructions match. Return Ok(type) if they do,
-/// and error otherwise.
-pub fn match_types(
-    lhs: &InstructionValue,
-    rhs: &InstructionValue,
-    builder: &Builder,
-) -> CompileResult<Type> {
-    let lhs_type = lhs.get_type(&builder);
-    let rhs_type = rhs.get_type(&builder);
-    if let (Ok(lhs_t), Ok(rhs_t)) = (lhs_type, rhs_type) {
-        if lhs_t == rhs_t {
-            Ok(lhs_t)
-        } else {
-            Err(ErrorKind::Null)
-        }
-    } else {
-        Err(ErrorKind::Null)
-    }
-}
--- a/reid-lsp/.gitignore
+++ b/reid-lsp/.gitignore
@ -3,4 +3,5 @@ node_modules
 dist
 package-lock.json
 pnpm-lock.yaml
-tsconfig.tsbuildinfo
+tsconfig.tsbuildinfo
+*.vsix
--- a/reid-lsp/CHANGELOG.md
+++ b/reid-lsp/CHANGELOG.md
@ -1,6 +1,6 @@
 # Change Log

-All notable changes to the "reid-lsp" extension will be documented in this file.
+All notable changes to the "reid-language-server" extension will be documented in this file.

 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.

--- a/reid-lsp/Cargo.toml
+++ b/reid-lsp/Cargo.toml
@ -1,11 +1,13 @@
 [package]
-name = "reid-lsp"
-version = "0.1.0"
+name = "reid-language-server"
+version = "1.0.0"
 edition = "2024"

 [dependencies]
 socket = "0.0.7"
 tokio = { version = "1.47.0", features = ["full"] }
 tower-lsp = "0.20.0"
-reid = { path = "../reid", version = "1.0.0-beta.2", registry="gitea-teascade", features=[] }
+reid = { path = "../reid", version = "1.0.0", registry="gitea-teascade", features=[] }
 dashmap = "6.1.0"
+serde = "*"
+serde_json = "*"
--- a/reid-lsp/README.md
+++ b/reid-lsp/README.md
@ -1,71 +1 @@
-# reid-lsp README
-
-This is the README for your extension "reid-lsp". After writing up a brief description, we recommend including the following sections.
-
-## Features
-
-Describe specific features of your extension including screenshots of your extension in action. Image paths are relative to this README file.
-
-For example if there is an image subfolder under your extension project workspace:
-
-\!\[feature X\]\(images/feature-x.png\)
-
-> Tip: Many popular extensions utilize animations. This is an excellent way to show off your extension! We recommend short, focused animations that are easy to follow.
-
-## Requirements
-
-If you have any requirements or dependencies, add a section describing those and how to install and configure them.
-
-## Extension Settings
-
-Include if your extension adds any VS Code settings through the `contributes.configuration` extension point.
-
-For example:
-
-This extension contributes the following settings:
-
-* `myExtension.enable`: Enable/disable this extension.
-* `myExtension.thing`: Set to `blah` to do something.
-
-## Known Issues
-
-Calling out known issues can help limit users opening duplicate issues against your extension.
-
-## Release Notes
-
-Users appreciate release notes as you update your extension.
-
-### 1.0.0
-
-Initial release of ...
-
-### 1.0.1
-
-Fixed issue #.
-
-### 1.1.0
-
-Added features X, Y, and Z.
-
---
-
-## Following extension guidelines
-
-Ensure that you've read through the extensions guidelines and follow the best practices for creating your extension.
-
-* [Extension Guidelines](https://code.visualstudio.com/api/references/extension-guidelines)
-
-## Working with Markdown
-
-You can author your README using Visual Studio Code. Here are some useful editor keyboard shortcuts:
-
-* Split the editor (`Cmd+\` on macOS or `Ctrl+\` on Windows and Linux).
-* Toggle preview (`Shift+Cmd+V` on macOS or `Shift+Ctrl+V` on Windows and Linux).
-* Press `Ctrl+Space` (Windows, Linux, macOS) to see a list of Markdown snippets.
-
-## For more information
-
-* [Visual Studio Code's Markdown Support](http://code.visualstudio.com/docs/languages/markdown)
-* [Markdown Syntax Reference](https://help.github.com/articles/markdown-basics/)
-
-**Enjoy!**
+# Reid Language Server
--- a/reid-lsp/client/src/extension.ts
+++ b/reid-lsp/client/src/extension.ts
@ -4,7 +4,7 @@
 * ------------------------------------------------------------------------------------------ */

 import * as path from 'path';
-import { workspace, ExtensionContext, window } from 'vscode';
+import { workspace, ExtensionContext, window, languages, SemanticTokensBuilder } from 'vscode';

 import {
 	Executable,
@ -18,16 +18,25 @@ import {
 let client: LanguageClient;

 export function activate(context: ExtensionContext) {
-	const traceOutputChannel = window.createOutputChannel("Reid Language Server trace");
-	const command = process.env.SERVER_PATH || "reid-language-server";
-
+	const configuration = workspace.getConfiguration('reid-language-server');
+	let server_path: string = process.env.SERVER_PATH ?? configuration.get("language-server-path") ?? 'reid-language-server';
+	const regex = /\$(\w+)/;
+	while (regex.test(server_path)) {
+		let envVar = regex.exec(server_path)?.[1];
+		const envVal = envVar ? process.env[envVar] : undefined;
+		if (envVar === undefined || envVal === undefined) {
+			console.error(`No such environment variables as ${envVar}`);
+		}
+		server_path = server_path.replaceAll(`$${envVar}`, envVal ?? '');
+	}

 	const run: Executable = {
-		command,
+		command: server_path,
 		options: {
 			env: {
 				...process.env,
 				RUST_LOG: "debug",
+				RUST_BACKTRACE: 1,
 			}
 		}
 	};
@ -44,21 +53,36 @@ export function activate(context: ExtensionContext) {
 		synchronize: {
 			// Notify the server about file changes to '.clientrc files contained in the workspace
 			fileEvents: workspace.createFileSystemWatcher('**/.clientrc')
-		}
+		},
 	};

 	// Create the language client and start the client.
 	client = new LanguageClient(
-		'reid-lsp',
+		'reid-language-server',
 		'Reid Language Server',
 		serverOptions,
 		clientOptions
 	);
+	client.info(JSON.stringify(server_path));

-	client.info("hello");
+	client.info(`Loaded Reid Language Server from ${server_path}`);

-	workspace.onDidOpenTextDocument((e) => {
-	});
+
+	workspace.onDidOpenTextDocument((e) => { });
+
+	client.info("Registering semantic tokens provide");
+	context.subscriptions.push(languages.registerDocumentSemanticTokensProvider({
+		language: 'reid',
+		scheme: 'file'
+	}, {
+		provideDocumentSemanticTokens: () => {
+			const builder = new SemanticTokensBuilder();
+			return builder.build();
+		}
+	}, {
+		tokenTypes: [],
+		tokenModifiers: [],
+	}));

 	// Start the client. This will also launch the server
 	client.start();
--- a/reid-lsp/language-configuration.json
+++ b/reid-lsp/language-configuration.json
@ -0,0 +1,92 @@
+{
+    "comments": {
+        "lineComment": "//",
+    },
+    "brackets": [
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ]
+    ],
+    "autoClosingPairs": [
+        {
+            "open": "{",
+            "close": "}"
+        },
+        {
+            "open": "[",
+            "close": "]"
+        },
+        {
+            "open": "(",
+            "close": ")"
+        },
+        {
+            "open": "'",
+            "close": "'",
+            "notIn": [
+                "string",
+                "comment"
+            ]
+        },
+        {
+            "open": "\"",
+            "close": "\"",
+            "notIn": [
+                "string"
+            ]
+        },
+    ],
+    "autoCloseBefore": ";:.,=}])>` \n\t",
+    "surroundingPairs": [
+        [
+            "{",
+            "}"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "(",
+            ")"
+        ],
+        [
+            "\"",
+            "\""
+        ],
+    ],
+    "folding": {
+        "markers": {
+            "start": "^\\s*//\\s*#?region\\b",
+            "end": "^\\s*//\\s*#?endregion\\b"
+        }
+    },
+    "wordPattern": "[a-Z](\\w*)",
+    "indentationRules": {
+        "increaseIndentPattern": "^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$",
+        "decreaseIndentPattern": "^((?!.*?\\/\\*).*\\*/)?\\s*[\\)\\}\\]].*$"
+    },
+    "colorizedBracketPairs": [
+        [
+            "(",
+            ")"
+        ],
+        [
+            "[",
+            "]"
+        ],
+        [
+            "{",
+            "}"
+        ]
+    ]
+}
--- a/reid-lsp/package.json
+++ b/reid-lsp/package.json
@ -1,46 +1,56 @@
 {
-  "name": "reid-lsp",
+  "name": "reid-language-server",
  "displayName": "Reid Language Server",
  "description": "Language Server Extension for Reid",
-  "version": "0.0.1",
+  "version": "1.0.0",
+  "repository": {
+    "url": "https://git.teascade.net/teascade"
+  },
  "engines": {
    "vscode": "^1.102.0"
  },
  "categories": [
    "Other"
  ],
-  "activationEvents": [
-    "onLanguage:reid"
-  ],
  "main": "./dist/extension.js",
+  "icon": "./reid.png",
+  "publisher": "Teascade",
+  "author": {
+    "email": "teascade@teascade.net",
+    "name": "Teascade",
+    "url": "https://teascade.net"
+  },
  "contributes": {
    "languages": [
      {
        "id": "reid",
        "extensions": [
          ".reid"
-        ]
+        ],
+        "aliases": [
+          "Reid"
+        ],
+        "configuration": "./language-configuration.json",
+        "icon": {
+          "dark": "./reid.png",
+          "light": "./reid.png"
+        }
+      }
+    ],
+    "breakpoints": [
+      {
+        "language": "reid"
      }
    ],
    "configuration": {
      "type": "object",
      "title": "reid-language-server",
      "properties": {
-        "nrs-language-server.trace.server": {
+        "reid-language-server.language-server-path": {
          "type": "string",
          "scope": "window",
-          "enum": [
-            "off",
-            "messages",
-            "verbose"
-          ],
-          "enumDescriptions": [
-            "No traces",
-            "Error only",
-            "Full log"
-          ],
-          "default": "off",
-          "description": "Traces the communication between VS Code and the language server."
+          "default": "$HOME/.cargo/bin/reid-language-server",
+          "description": "Path to the Reid Language Server executable"
        }
      }
    },
--- a/reid-lsp/reid.png
+++ b/reid-lsp/reid.png
--- a/reid-lsp/src/analysis.rs
+++ b/reid-lsp/src/analysis.rs
--- a/reid-lsp/src/main.rs
+++ b/reid-lsp/src/main.rs
@ -3,27 +3,41 @@ use std::path::PathBuf;

 use dashmap::DashMap;
 use reid::ast::lexer::{FullToken, Position};
-use reid::error_raporting::{ErrorModules, ReidError};
-use reid::mir::{
-    self, Context, FunctionCall, FunctionDefinition, FunctionParam, IfExpression, SourceModuleId, StructType, TypeKind,
-    WhileStatement,
-};
-use reid::{compile_module, parse_module, perform_all_passes};
+use reid::error_raporting::{self, ErrorModules, ReidError};
+use reid::mir::SourceModuleId;
+use reid::parse_module;
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
 use tower_lsp::lsp_types::{
    self, CompletionItem, CompletionOptions, CompletionParams, CompletionResponse, Diagnostic, DiagnosticSeverity,
-    DidChangeTextDocumentParams, DidOpenTextDocumentParams, Hover, HoverContents, HoverParams, HoverProviderCapability,
-    InitializeParams, InitializeResult, InitializedParams, MarkedString, MarkupContent, MarkupKind, MessageType, OneOf,
-    Range, ServerCapabilities, TextDocumentItem, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextDocumentSyncOptions, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
+    DidChangeTextDocumentParams, DidOpenTextDocumentParams, DidSaveTextDocumentParams, DocumentFilter,
+    GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents, HoverParams, HoverProviderCapability,
+    InitializeParams, InitializeResult, InitializedParams, Location, MarkedString, MarkupContent, MarkupKind,
+    MessageType, OneOf, Range, ReferenceParams, RenameParams, SemanticToken, SemanticTokensLegend,
+    SemanticTokensOptions, SemanticTokensParams, SemanticTokensResult, SemanticTokensServerCapabilities,
+    ServerCapabilities, TextDocumentItem, TextDocumentRegistrationOptions, TextDocumentSyncCapability,
+    TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions, TextEdit, Url, WorkspaceEdit,
+    WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
 };
 use tower_lsp::{Client, LanguageServer, LspService, Server, jsonrpc};

+use crate::analysis::{MODIFIER_LEGEND, StateMap, StaticAnalysis, TOKEN_LEGEND, analyze};
+
+mod analysis;
+
 #[derive(Debug)]
 struct Backend {
    client: Client,
-    tokens: DashMap<String, Vec<FullToken>>,
-    ast: DashMap<String, reid::ast::Module>,
-    types: DashMap<String, DashMap<FullToken, Option<TypeKind>>>,
+    analysis: DashMap<PathBuf, StaticAnalysis>,
+    module_to_path: DashMap<SourceModuleId, PathBuf>,
+    path_to_module: DashMap<PathBuf, SourceModuleId>,
+    module_id_counter: Mutex<SourceModuleId>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct CompletionData {
+    token_idx: usize,
+    path: PathBuf,
 }

 #[tower_lsp::async_trait]
@ -38,29 +52,67 @@ impl LanguageServer for Backend {
            change: Some(TextDocumentSyncKind::FULL),
            will_save: None,
            will_save_wait_until: None,
-            save: None,
+            save: Some(TextDocumentSyncSaveOptions::SaveOptions(lsp_types::SaveOptions {
+                include_text: Some(true),
+            })),
+        };
+
+        let capabilities = ServerCapabilities {
+            hover_provider: Some(HoverProviderCapability::Simple(true)),
+            completion_provider: Some(CompletionOptions {
+                trigger_characters: None,
+                all_commit_characters: None,
+                completion_item: Some(lsp_types::CompletionOptionsCompletionItem {
+                    label_details_support: Some(true),
+                }),
+                resolve_provider: Some(false),
+                work_done_progress_options: lsp_types::WorkDoneProgressOptions {
+                    work_done_progress: Some(true),
+                },
+            }),
+            text_document_sync: Some(TextDocumentSyncCapability::Options(sync)),
+            workspace: Some(WorkspaceServerCapabilities {
+                workspace_folders: Some(WorkspaceFoldersServerCapabilities {
+                    supported: Some(true),
+                    change_notifications: Some(OneOf::Left(true)),
+                }),
+                file_operations: None,
+            }),
+            semantic_tokens_provider: Some(SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(
+                lsp_types::SemanticTokensRegistrationOptions {
+                    text_document_registration_options: TextDocumentRegistrationOptions {
+                        document_selector: Some(vec![DocumentFilter {
+                            language: Some("reid".to_owned()),
+                            scheme: Some("file".to_owned()),
+                            pattern: None,
+                        }]),
+                    },
+                    semantic_tokens_options: SemanticTokensOptions {
+                        work_done_progress_options: Default::default(),
+                        legend: SemanticTokensLegend {
+                            token_types: TOKEN_LEGEND.into(),
+                            token_modifiers: MODIFIER_LEGEND.into(),
+                        },
+                        range: None,
+                        full: Some(lsp_types::SemanticTokensFullOptions::Bool(true)),
+                    },
+                    static_registration_options: Default::default(),
+                },
+            )),
+            references_provider: Some(OneOf::Left(true)),
+            definition_provider: Some(OneOf::Left(true)),
+            rename_provider: Some(OneOf::Left(true)),
+            ..Default::default()
        };
        Ok(InitializeResult {
-            capabilities: ServerCapabilities {
-                hover_provider: Some(HoverProviderCapability::Simple(true)),
-                completion_provider: Some(CompletionOptions { ..Default::default() }),
-                text_document_sync: Some(TextDocumentSyncCapability::Options(sync)),
-                workspace: Some(WorkspaceServerCapabilities {
-                    workspace_folders: Some(WorkspaceFoldersServerCapabilities {
-                        supported: Some(true),
-                        change_notifications: Some(OneOf::Left(true)),
-                    }),
-                    file_operations: None,
-                }),
-                ..Default::default()
-            },
+            capabilities,
            ..Default::default()
        })
    }

    async fn initialized(&self, _: InitializedParams) {
        self.client
-            .log_message(MessageType::INFO, "Reid Language Server initialized hello!")
+            .log_message(MessageType::INFO, "Reid Language Server initialized!")
            .await;
    }

@ -69,20 +121,64 @@ impl LanguageServer for Backend {
    }

    async fn completion(&self, params: CompletionParams) -> jsonrpc::Result<Option<CompletionResponse>> {
-        Ok(Some(CompletionResponse::Array(vec![
-            CompletionItem::new_simple("Hello".to_string(), "Some detail".to_string()),
-            CompletionItem::new_simple("Bye".to_string(), "More detail".to_string()),
-        ])))
+        let path = PathBuf::from(params.text_document_position.text_document.uri.path());
+        let analysis = self.analysis.get(&path);
+        let position = params.text_document_position.position;
+
+        let token = if let Some(analysis) = &analysis {
+            analysis.tokens.iter().enumerate().find(|(_, tok)| {
+                tok.position.1 == position.line + 1
+                    && (tok.position.0 <= position.character
+                        && (tok.position.0 + tok.token.len() as u32) > position.character)
+            })
+        } else {
+            None
+        };
+
+        // dbg!(position, token);
+
+        let list = if let Some((idx, _)) = token {
+            if let Some(token_analysis) = self.analysis.get(&path).unwrap().state.map.get(&idx) {
+                token_analysis
+                    .autocomplete
+                    .iter()
+                    .map(|autocomplete| {
+                        let mut item =
+                            CompletionItem::new_simple(autocomplete.text.to_string(), autocomplete.kind.to_string());
+                        item.data = Some(
+                            serde_json::to_value(CompletionData {
+                                token_idx: idx,
+                                path: path.clone(),
+                            })
+                            .unwrap(),
+                        );
+                        item.documentation = autocomplete.documentation.as_ref().and_then(|d| {
+                            Some(lsp_types::Documentation::MarkupContent(MarkupContent {
+                                kind: MarkupKind::Markdown,
+                                value: d.clone(),
+                            }))
+                        });
+                        item
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        } else {
+            Vec::new()
+        };
+
+        // dbg!(&list);
+        Ok(Some(CompletionResponse::Array(list)))
    }

    async fn hover(&self, params: HoverParams) -> jsonrpc::Result<Option<Hover>> {
        let path = PathBuf::from(params.text_document_position_params.text_document.uri.path());
-        let file_name = path.file_name().unwrap().to_str().unwrap().to_owned();
-        let tokens = self.tokens.get(&file_name);
+        let analysis = self.analysis.get(&path);
        let position = params.text_document_position_params.position;

-        let token = if let Some(tokens) = &tokens {
-            tokens.iter().find(|tok| {
+        let token = if let Some(analysis) = &analysis {
+            analysis.tokens.iter().enumerate().find(|(_, tok)| {
                tok.position.1 == position.line + 1
                    && (tok.position.0 <= position.character + 1
                        && (tok.position.0 + tok.token.len() as u32) > position.character + 1)
@ -91,8 +187,8 @@ impl LanguageServer for Backend {
            None
        };

-        let (range, ty) = if let Some(token) = token {
-            if let Some(possible_ty) = self.types.get(&file_name).unwrap().get(token) {
+        let (range, ty, documentation) = if let Some((idx, token)) = token {
+            if let Some(analysis) = self.analysis.get(&path).unwrap().state.map.get(&idx) {
                let start = token.position;
                let end = token.position.add(token.token.len() as u32);
                let range = Range {
@ -105,22 +201,50 @@ impl LanguageServer for Backend {
                        character: (end.0 as i32 - 1).max(0) as u32,
                    },
                };
-                if let Some(ty) = possible_ty.clone() {
-                    (Some(range), format!("{}", ty))
+                if let Some(kind) = &analysis.hover.kind {
+                    match kind {
+                        analysis::HoverKind::Type(type_kind) => (
+                            Some(range),
+                            format!("{}", type_kind),
+                            analysis.hover.documentation.clone(),
+                        ),
+                        analysis::HoverKind::Function(name, function_params, return_type) => (
+                            Some(range),
+                            format!(
+                                "{}({}) -> {}",
+                                name,
+                                function_params
+                                    .iter()
+                                    .map(|p| format!("{}: {}", p.name, p.ty))
+                                    .collect::<Vec<_>>()
+                                    .join(", "),
+                                return_type
+                            ),
+                            analysis.hover.documentation.clone(),
+                        ),
+                    }
                } else {
-                    (Some(range), String::from("no type"))
+                    (
+                        Some(range),
+                        String::from("No type"),
+                        analysis.hover.documentation.clone(),
+                    )
                }
            } else {
-                (None, String::from("no token"))
+                (None, String::from("no type"), None)
            }
        } else {
-            (None, String::from("no token"))
+            (None, String::from("no token"), None)
        };

-        let contents = HoverContents::Markup(MarkupContent {
-            kind: MarkupKind::Markdown,
-            value: format!("`{ty}`"),
-        });
+        let contents = if let Some(doc) = documentation {
+            HoverContents::Array(vec![MarkedString::String(doc), MarkedString::String(format!("`{ty}`"))])
+        } else {
+            HoverContents::Markup(MarkupContent {
+                kind: MarkupKind::Markdown,
+                value: format!("`{ty}`"),
+            })
+        };

        Ok(Some(Hover { contents, range }))
    }
@ -144,60 +268,270 @@ impl LanguageServer for Backend {
        })
        .await
    }
+
+    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+        self.recompile(TextDocumentItem {
+            text: params.text.unwrap(),
+            uri: params.text_document.uri,
+            version: 0,
+            language_id: String::new(),
+        })
+        .await
+    }
+
+    async fn semantic_tokens_full(
+        &self,
+        params: SemanticTokensParams,
+    ) -> jsonrpc::Result<Option<SemanticTokensResult>> {
+        let path = PathBuf::from(params.text_document.uri.path());
+        let analysis = self.analysis.get(&path);
+
+        let mut semantic_tokens = Vec::new();
+        if let Some(analysis) = analysis {
+            let mut prev_line = 0;
+            let mut prev_start = 0;
+            for (i, token) in analysis.tokens.iter().enumerate() {
+                let vscode_line = token.position.1.max(1) - 1;
+                let vscode_col = token.position.0.max(1) - 1;
+
+                let delta_line = vscode_line - prev_line;
+                let delta_start = if delta_line == 0 {
+                    vscode_col - prev_start
+                } else {
+                    vscode_col
+                };
+
+                if let Some(token_analysis) = analysis.state.map.get(&i) {
+                    if let Some(symbol_id) = token_analysis.symbol {
+                        let symbol = analysis.state.get_local_symbol(symbol_id);
+                        if let Some(idx) = symbol.kind.into_token_idx(&self.state_map()) {
+                            let semantic_token = SemanticToken {
+                                delta_line,
+                                delta_start,
+                                length: token.token.len() as u32,
+                                token_type: idx,
+                                token_modifiers_bitset: symbol.kind.get_modifier().unwrap_or(0),
+                            };
+                            semantic_tokens.push(semantic_token);
+                            prev_line = vscode_line;
+                            prev_start = vscode_col;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(Some(SemanticTokensResult::Tokens(lsp_types::SemanticTokens {
+            result_id: None,
+            data: semantic_tokens,
+        })))
+    }
+
+    async fn goto_definition(&self, params: GotoDefinitionParams) -> jsonrpc::Result<Option<GotoDefinitionResponse>> {
+        let path = PathBuf::from(params.text_document_position_params.text_document.uri.path());
+        let analysis = self.analysis.get(&path);
+        let position = params.text_document_position_params.position;
+
+        if let Some(analysis) = &analysis {
+            let token = analysis.tokens.iter().enumerate().find(|(_, tok)| {
+                tok.position.1 == position.line + 1
+                    && (tok.position.0 <= position.character + 1
+                        && (tok.position.0 + tok.token.len() as u32) > position.character + 1)
+            });
+
+            if let Some(token) = token {
+                if let Some((module_id, def_token)) = analysis.find_definition(token.0, &self.state_map()) {
+                    return if let Some(path) = self.module_to_path.get(&module_id) {
+                        Ok(Some(GotoDefinitionResponse::Scalar(lsp_types::Location {
+                            uri: Url::from_file_path(path.value()).unwrap(),
+                            range: token_to_range(def_token),
+                        })))
+                    } else {
+                        Ok(None)
+                    };
+                }
+            }
+        };
+
+        Ok(None)
+    }
+
+    async fn references(&self, params: ReferenceParams) -> jsonrpc::Result<Option<Vec<Location>>> {
+        let path = PathBuf::from(params.text_document_position.text_document.uri.path());
+        let analysis = self.analysis.get(&path);
+        let position = params.text_document_position.position;
+
+        if let Some(analysis) = &analysis {
+            let token = analysis.tokens.iter().enumerate().find(|(_, tok)| {
+                tok.position.1 == position.line + 1
+                    && (tok.position.0 <= position.character + 1
+                        && (tok.position.0 + tok.token.len() as u32) > position.character + 1)
+            });
+            if let Some(token) = token {
+                let reference_tokens = analysis.find_references(token.0, &self.state_map());
+                let mut locations = Vec::new();
+                if let Some(reference_tokens) = reference_tokens {
+                    for (module_id, symbol_idx) in reference_tokens {
+                        if let Some(path) = self.module_to_path.get(&module_id) {
+                            let url = Url::from_file_path(path.value()).unwrap();
+                            if let Some(inner_analysis) = self.analysis.get(path.value()) {
+                                if let Some(token_idx) = inner_analysis.state.symbol_to_token.get(&symbol_idx) {
+                                    let token = inner_analysis.tokens.get(*token_idx).unwrap();
+
+                                    locations.push(lsp_types::Location {
+                                        uri: url,
+                                        range: token_to_range(token),
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                Ok(Some(locations))
+            } else {
+                Ok(None)
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn rename(&self, params: RenameParams) -> jsonrpc::Result<Option<WorkspaceEdit>> {
+        let path = PathBuf::from(params.text_document_position.text_document.uri.path());
+        let analysis = self.analysis.get(&path);
+        let position = params.text_document_position.position;
+
+        if let Some(analysis) = &analysis {
+            let token = analysis.tokens.iter().enumerate().find(|(_, tok)| {
+                tok.position.1 == position.line + 1
+                    && (tok.position.0 <= position.character + 1
+                        && (tok.position.0 + tok.token.len() as u32) > position.character + 1)
+            });
+            if let Some(token) = token {
+                let symbols = analysis.find_references(token.0, &self.state_map());
+                let mut changes: HashMap<Url, Vec<TextEdit>> = HashMap::new();
+                if let Some(symbols) = symbols {
+                    for (module_id, symbol_id) in symbols {
+                        let path = self.module_to_path.get(&module_id);
+                        if let Some(path) = path {
+                            let url = Url::from_file_path(path.value()).unwrap();
+                            let analysis = self.analysis.get(&path.clone());
+
+                            if let Some(analysis) = analysis {
+                                if let Some(token_idx) = analysis.state.symbol_to_token.get(&symbol_id) {
+                                    let token = analysis.tokens.get(*token_idx).unwrap();
+
+                                    // edits = changes.get(k)
+                                    let edit = TextEdit {
+                                        range: token_to_range(token),
+                                        new_text: params.new_name.clone(),
+                                    };
+                                    if let Some(edits) = changes.get_mut(&url) {
+                                        edits.push(edit);
+                                    } else {
+                                        changes.insert(url, vec![edit]);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                Ok(Some(WorkspaceEdit {
+                    changes: Some(changes),
+                    document_changes: None,
+                    change_annotations: None,
+                }))
+            } else {
+                Ok(None)
+            }
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+fn token_to_range(token: &FullToken) -> lsp_types::Range {
+    Range {
+        start: lsp_types::Position {
+            line: token.position.1.max(1) - 1,
+            character: token.position.0.max(1) - 1,
+        },
+        end: lsp_types::Position {
+            line: token.position.1.max(1) - 1,
+            character: token.position.0.max(1) - 1 + token.token.len() as u32,
+        },
+    }
 }

 impl Backend {
-    async fn recompile(&self, params: TextDocumentItem) {
-        let path = PathBuf::from(params.uri.clone().path());
-        let file_name = path.file_name().unwrap().to_str().unwrap().to_owned();
+    fn state_map(&self) -> StateMap {
+        let mut state_map = HashMap::new();
+        for path_state in self.analysis.iter() {
+            let (path, state) = path_state.pair();
+            if let Some(module_id) = self.path_to_module.get(path) {
+                state_map.insert(*module_id, state.state.clone());
+            }
+        }
+        state_map
+    }

-        let mut map = Default::default();
-        let parse_res = parse(&params.text, path.clone(), &mut map);
+    async fn recompile(&self, params: TextDocumentItem) {
+        let file_path = PathBuf::from(params.uri.clone().path());
+
+        let mut map: ErrorModules = Default::default();
+        for url_module in self.path_to_module.iter() {
+            let (url, module) = url_module.pair();
+            map.add_module(
+                url.file_name().unwrap().to_str().unwrap().to_owned(),
+                Some(url.clone()),
+                Some(*module),
+            );
+        }
+
+        let module_id = if let Some(module_id) = self.path_to_module.get(&file_path) {
+            *module_id
+        } else {
+            let mut lock = self.module_id_counter.lock().await;
+            let module_id = lock.increment();
+            drop(lock);
+            self.path_to_module.insert(file_path.clone(), module_id);
+            self.module_to_path.insert(module_id, file_path.clone());
+            module_id
+        };
+
+        let parse_res = parse(&params.text, file_path.clone(), &mut map, module_id);
        let (tokens, result) = match parse_res {
-            Ok((module_id, tokens)) => (tokens.clone(), compile(module_id, tokens, path, &mut map)),
+            Ok((module_id, tokens)) => (
+                tokens.clone(),
+                analyze(module_id, tokens, file_path.clone(), &mut map, &self.state_map()),
+            ),
            Err(e) => (Vec::new(), Err(e)),
        };

        let mut diagnostics = Vec::new();
        match result {
-            Ok(Some(result)) => {
-                self.tokens.insert(file_name.clone(), result.tokens);
-                self.types.insert(file_name.clone(), result.types);
+            Ok(Some(mut analysis)) => {
+                if let Some(reid_error) = &mut analysis.error {
+                    self.client
+                        .log_message(
+                            MessageType::INFO,
+                            format!("Successfully compiled despite parsing errors!"),
+                        )
+                        .await;
+                    reid_error.errors.dedup();
+                    for error in &reid_error.errors {
+                        diagnostics.push(reid_error_into_diagnostic(error, &tokens));
+                        self.client.log_message(MessageType::INFO, format!("{}", error)).await;
+                    }
+                }
+                self.analysis.insert(file_path, analysis);
            }
            Ok(_) => {}
            Err(mut reid_error) => {
                reid_error.errors.dedup();
-                for error in reid_error.errors {
-                    let meta = error.get_meta();
-                    let positions = meta
-                        .range
-                        .into_position(&tokens)
-                        .unwrap_or((Position(0, 0), Position(0, 0)));
-                    self.client.log_message(MessageType::INFO, format!("{:?}", &meta)).await;
-                    self.client
-                        .log_message(MessageType::INFO, format!("{:?}", &positions))
-                        .await;
-
-                    diagnostics.push(Diagnostic {
-                        range: Range {
-                            start: lsp_types::Position {
-                                line: ((positions.0.1 as i32) - 1).max(0) as u32,
-                                character: ((positions.0.0 as i32) - 1).max(0) as u32,
-                            },
-                            end: lsp_types::Position {
-                                line: ((positions.1.1 as i32) - 1).max(0) as u32,
-                                character: ((positions.1.0 as i32) - 1).max(0) as u32,
-                            },
-                        },
-                        severity: Some(DiagnosticSeverity::ERROR),
-                        code: None,
-                        code_description: None,
-                        source: Some(error.get_type_str().to_owned()),
-                        message: format!("{}", error),
-                        related_information: None,
-                        tags: None,
-                        data: None,
-                    });
+                for error in &reid_error.errors {
+                    diagnostics.push(reid_error_into_diagnostic(error, &tokens));
                    self.client.log_message(MessageType::INFO, format!("{}", error)).await;
                }
            }
@ -209,45 +543,50 @@ impl Backend {
    }
 }

-struct CompileResult {
-    tokens: Vec<FullToken>,
-    types: DashMap<FullToken, Option<TypeKind>>,
+fn reid_error_into_diagnostic(error: &error_raporting::ErrorKind, tokens: &Vec<FullToken>) -> Diagnostic {
+    let meta = error.get_meta();
+    let positions = meta
+        .range
+        .into_position(&tokens)
+        .unwrap_or((Position(0, 0), Position(0, 0)));
+
+    Diagnostic {
+        range: Range {
+            start: lsp_types::Position {
+                line: ((positions.0.1 as i32) - 1).max(0) as u32,
+                character: ((positions.0.0 as i32) - 1).max(0) as u32,
+            },
+            end: lsp_types::Position {
+                line: ((positions.1.1 as i32) - 1).max(0) as u32,
+                character: ((positions.1.0 as i32) - 1).max(0) as u32,
+            },
+        },
+        severity: Some(DiagnosticSeverity::ERROR),
+        code: None,
+        code_description: None,
+        source: Some(error.get_type_str().to_owned()),
+        message: format!("{}", error),
+        related_information: None,
+        tags: None,
+        data: None,
+    }
 }

-fn parse(source: &str, path: PathBuf, map: &mut ErrorModules) -> Result<(SourceModuleId, Vec<FullToken>), ReidError> {
-    let file_name = path.file_name().unwrap().to_str().unwrap().to_owned();
-
-    Ok(parse_module(source, file_name.clone(), map)?)
-}
-
-fn compile(
-    module_id: SourceModuleId,
-    tokens: Vec<FullToken>,
+fn parse(
+    source: &str,
    path: PathBuf,
    map: &mut ErrorModules,
-) -> Result<Option<CompileResult>, ReidError> {
-    let token_types = DashMap::new();
+    module_id: SourceModuleId,
+) -> Result<(SourceModuleId, Vec<FullToken>), ReidError> {
+    let file_name = path.file_name().unwrap().to_str().unwrap().to_owned();

-    let module = compile_module(module_id, tokens, map, Some(path.clone()), true)?;
-
-    let module_id = module.module_id;
-    let mut context = Context::from(vec![module], path.parent().unwrap().to_owned());
-    perform_all_passes(&mut context, map)?;
-
-    for module in context.modules.into_values() {
-        if module.module_id != module_id {
-            continue;
-        }
-        for (idx, token) in module.tokens.iter().enumerate() {
-            token_types.insert(token.clone(), find_type_in_context(&module, idx));
-        }
-
-        return Ok(Some(CompileResult {
-            tokens: module.tokens,
-            types: token_types,
-        }));
-    }
-    return Ok(None);
+    Ok(parse_module(
+        source,
+        file_name.clone(),
+        Some(path),
+        map,
+        Some(module_id),
+    )?)
 }

 #[tokio::main]
@ -257,234 +596,10 @@ async fn main() {

    let (service, socket) = LspService::new(|client| Backend {
        client,
-        ast: DashMap::new(),
-        tokens: DashMap::new(),
-        types: DashMap::new(),
+        analysis: DashMap::new(),
+        module_to_path: DashMap::new(),
+        path_to_module: DashMap::new(),
+        module_id_counter: Mutex::new(SourceModuleId(0)),
    });
    Server::new(stdin, stdout, socket).serve(service).await;
 }
-
-pub fn find_type_in_context(module: &mir::Module, token_idx: usize) -> Option<TypeKind> {
-    for import in &module.imports {
-        if import.1.contains(token_idx) {
-            return None;
-        }
-    }
-    for typedef in &module.typedefs {
-        if !typedef.meta.contains(token_idx) {
-            continue;
-        }
-
-        match &typedef.kind {
-            mir::TypeDefinitionKind::Struct(StructType(fields)) => {
-                for field in fields {
-                    if field.2.contains(token_idx) {
-                        return Some(field.1.clone());
-                    }
-                }
-            }
-        }
-    }
-
-    for binop in &module.binop_defs {
-        if let Some(meta) = binop.block_meta() {
-            if !meta.contains(token_idx) {
-                continue;
-            }
-        } else {
-            continue;
-        }
-
-        return match &binop.fn_kind {
-            mir::FunctionDefinitionKind::Local(block, _) => find_type_in_block(&block, module.module_id, token_idx),
-            mir::FunctionDefinitionKind::Extern(_) => None,
-            mir::FunctionDefinitionKind::Intrinsic(_) => None,
-        };
-    }
-
-    for (_, function) in &module.associated_functions {
-        if !(function.signature() + function.block_meta()).contains(token_idx) {
-            continue;
-        }
-
-        for param in &function.parameters {
-            if param.meta.contains(token_idx) {
-                return Some(param.ty.clone());
-            }
-        }
-
-        return match &function.kind {
-            mir::FunctionDefinitionKind::Local(block, _) => find_type_in_block(&block, module.module_id, token_idx),
-            mir::FunctionDefinitionKind::Extern(_) => None,
-            mir::FunctionDefinitionKind::Intrinsic(_) => None,
-        };
-    }
-
-    for function in &module.functions {
-        if !(function.signature() + function.block_meta()).contains(token_idx) {
-            continue;
-        }
-
-        for param in &function.parameters {
-            if param.meta.contains(token_idx) {
-                return Some(param.ty.clone());
-            }
-        }
-
-        return match &function.kind {
-            mir::FunctionDefinitionKind::Local(block, _) => find_type_in_block(&block, module.module_id, token_idx),
-            mir::FunctionDefinitionKind::Extern(_) => None,
-            mir::FunctionDefinitionKind::Intrinsic(_) => None,
-        };
-    }
-    None
-}
-
-pub fn find_type_in_block(block: &mir::Block, module_id: SourceModuleId, token_idx: usize) -> Option<TypeKind> {
-    if !block.meta.contains(token_idx) {
-        return None;
-    }
-
-    for statement in &block.statements {
-        if !statement.1.contains(token_idx) {
-            continue;
-        }
-        match &statement.0 {
-            mir::StmtKind::Let(named_variable_ref, _, expression) => {
-                if named_variable_ref.2.contains(token_idx) {
-                    return expression
-                        .return_type(&Default::default(), module_id)
-                        .ok()
-                        .map(|(_, ty)| ty);
-                } else {
-                    return find_type_in_expr(&expression, module_id, token_idx);
-                }
-            }
-            mir::StmtKind::Set(lhs, rhs) => {
-                return find_type_in_expr(lhs, module_id, token_idx).or(find_type_in_expr(rhs, module_id, token_idx));
-            }
-            mir::StmtKind::Import(_) => {}
-            mir::StmtKind::Expression(expression) => return find_type_in_expr(expression, module_id, token_idx),
-            mir::StmtKind::While(WhileStatement { condition, block, .. }) => {
-                return find_type_in_expr(condition, module_id, token_idx)
-                    .or(find_type_in_block(block, module_id, token_idx));
-            }
-        }
-    }
-
-    if let Some((_, Some(return_exp))) = &block.return_expression {
-        if let Some(ty) = find_type_in_expr(return_exp, module_id, token_idx) {
-            return Some(ty);
-        }
-    }
-
-    None
-}
-
-pub fn find_type_in_expr(expr: &mir::Expression, module_id: SourceModuleId, token_idx: usize) -> Option<TypeKind> {
-    if !expr.1.contains(token_idx) {
-        return None;
-    }
-
-    match &expr.0 {
-        mir::ExprKind::Variable(named_variable_ref) => Some(named_variable_ref.0.clone()),
-        mir::ExprKind::Indexed(value, type_kind, index_expr) => Some(
-            find_type_in_expr(&value, module_id, token_idx)
-                .or(find_type_in_expr(&index_expr, module_id, token_idx))
-                .unwrap_or(type_kind.clone()),
-        ),
-        mir::ExprKind::Accessed(expression, type_kind, _, meta) => {
-            if meta.contains(token_idx) {
-                Some(type_kind.clone())
-            } else {
-                find_type_in_expr(&expression, module_id, token_idx)
-            }
-        }
-        mir::ExprKind::Array(expressions) => {
-            for expr in expressions {
-                if let Some(ty) = find_type_in_expr(expr, module_id, token_idx) {
-                    return Some(ty);
-                }
-            }
-            None
-        }
-        mir::ExprKind::Struct(name, items) => {
-            for (_, expr, meta) in items {
-                if meta.contains(token_idx) {
-                    return expr.return_type(&Default::default(), module_id).map(|(_, t)| t).ok();
-                }
-                if let Some(ty) = find_type_in_expr(expr, module_id, token_idx) {
-                    return Some(ty);
-                }
-            }
-            Some(TypeKind::CustomType(mir::CustomTypeKey(name.clone(), module_id)))
-        }
-        mir::ExprKind::Literal(literal) => Some(literal.as_type()),
-        mir::ExprKind::BinOp(_, lhs, rhs, type_kind) => {
-            if let Some(ty) = find_type_in_expr(lhs, module_id, token_idx) {
-                return Some(ty);
-            }
-            if let Some(ty) = find_type_in_expr(rhs, module_id, token_idx) {
-                return Some(ty);
-            }
-            Some(type_kind.clone())
-        }
-        mir::ExprKind::FunctionCall(FunctionCall {
-            return_type,
-            parameters,
-            ..
-        }) => {
-            for expr in parameters {
-                if let Some(ty) = find_type_in_expr(expr, module_id, token_idx) {
-                    return Some(ty);
-                }
-            }
-            Some(return_type.clone())
-        }
-        mir::ExprKind::AssociatedFunctionCall(
-            _,
-            FunctionCall {
-                return_type,
-                parameters,
-                ..
-            },
-        ) => {
-            for expr in parameters {
-                if let Some(ty) = find_type_in_expr(expr, module_id, token_idx) {
-                    return Some(ty);
-                }
-            }
-            Some(return_type.clone())
-        }
-        mir::ExprKind::If(IfExpression(cond, then_e, else_e)) => find_type_in_expr(&cond, module_id, token_idx)
-            .or(find_type_in_expr(&then_e, module_id, token_idx))
-            .or(else_e.clone().and_then(|e| find_type_in_expr(&e, module_id, token_idx))),
-        mir::ExprKind::Block(block) => find_type_in_block(block, module_id, token_idx),
-        mir::ExprKind::Borrow(expression, mutable) => {
-            if let Some(ty) = find_type_in_expr(&expression, module_id, token_idx) {
-                return Some(ty);
-            }
-            if let Ok(inner) = expression.return_type(&Default::default(), module_id).map(|(_, ty)| ty) {
-                Some(TypeKind::Borrow(Box::new(inner.clone()), *mutable))
-            } else {
-                None
-            }
-        }
-        mir::ExprKind::Deref(expression) => {
-            if let Some(ty) = find_type_in_expr(&expression, module_id, token_idx) {
-                return Some(ty);
-            }
-            if let Ok(TypeKind::Borrow(inner, _)) =
-                expression.return_type(&Default::default(), module_id).map(|(_, ty)| ty)
-            {
-                Some(*inner.clone())
-            } else {
-                None
-            }
-        }
-        mir::ExprKind::CastTo(expression, type_kind) => {
-            Some(find_type_in_expr(&expression, module_id, token_idx).unwrap_or(type_kind.clone()))
-        }
-        mir::ExprKind::GlobalRef(_, type_kind) => Some(type_kind.clone()),
-    }
-}
--- a/reid-lsp/syntaxes/grammar.json
+++ b/reid-lsp/syntaxes/grammar.json
@ -1,56 +1,11 @@
 {
  "scopeName": "source.reid",
  "patterns": [
-    {
-      "include": "#import"
-    },
    {
      "include": "#expression"
    }
  ],
  "repository": {
-    "import": {
-      "begin": "(import)\\s*",
-      "end": ";",
-      "beginCaptures": {
-        "1": {
-          "name": "keyword"
-        }
-      },
-      "endCaptures": {
-        "0": {
-          "name": "punctuation.semi.reid"
-        }
-      },
-      "patterns": [
-        {
-          "include": "#identifier"
-        },
-        {
-          "include": "#punctiation"
-        }
-      ]
-    },
-    "punctuation": {
-      "patterns": [
-        {
-          "match": "::",
-          "name": "keyword.operator.namespace.reid"
-        },
-        {
-          "match": ";",
-          "name": "punctuation.semi.reid"
-        },
-        {
-          "match": ".",
-          "name": "punctuation.dot.reid"
-        },
-        {
-          "match": ",",
-          "name": "punctuation.comma.reid"
-        }
-      ]
-    },
    "expression": {
      "patterns": [
        {
@ -59,27 +14,18 @@
        {
          "include": "#fn-signature"
        },
+        {
+          "include": "#namespace"
+        },
        {
          "include": "#common-type"
        },
-        {
-          "include": "#binop-impl"
-        },
-        {
-          "include": "#type-impl"
-        },
        {
          "include": "#struct-definition"
        },
-        {
-          "include": "#block"
-        },
        {
          "include": "#binop"
        },
-        {
-          "include": "#namespace"
-        },
        {
          "include": "#cast"
        },
@ -95,9 +41,6 @@
        {
          "include": "#keywords"
        },
-        {
-          "include": "#struct-expression"
-        },
        {
          "include": "#number-literal"
        },
@ -112,93 +55,44 @@
        }
      ]
    },
+    "punctuation": {
+      "patterns": [
+        {
+          "match": "::",
+          "name": "keyword.operator.namespace.reid"
+        },
+        {
+          "match": ":",
+          "name": "keyword.operator.colon.reid"
+        },
+        {
+          "match": ";",
+          "name": "punctuation.semi.reid"
+        },
+        {
+          "match": ".",
+          "name": "punctuation.dot.reid"
+        },
+        {
+          "match": ",",
+          "name": "punctuation.comma.reid"
+        },
+        {
+          "match": "\\{|\\}",
+          "name": "punctuation.brackets.curly.reid"
+        },
+        {
+          "match": "\\(|\\)",
+          "name": "punctuation.parenthesis.reid"
+        }
+      ]
+    },
    "comment": {
      "match": "\\/\\/(.|\\/)*",
      "name": "comment.line.double-slash.reid"
    },
-    "fn-signature": {
-      "begin": "(fn)\\s*(\\w+)\\(",
-      "beginCaptures": {
-        "1": {
-          "name": "keyword.fn.reid"
-        },
-        "2": {
-          "name": "entity.name.function.reid"
-        }
-      },
-      "end": "\\)",
-      "patterns": [
-        {
-          "include": "#annotated-identifier"
-        },
-        {
-          "include": "#keywords"
-        },
-        {
-          "include": "#binop"
-        }
-      ],
-      "endCaptures": {
-        "2": {
-          "name": "entity.name.type.reid"
-        }
-      }
-    },
-    "type-impl": {
-      "begin": "(impl)\\s* (\\w+)\\s* \\{\n",
-      "end": "\\}",
-      "captures": {
-        "1": {
-          "name": "keyword.impl.reid"
-        },
-        "2": {
-          "name": "entity.name.type"
-        }
-      },
-      "patterns": [
-        {
-          "include": "#expression"
-        }
-      ]
-    },
-    "binop-impl": {
-      "begin": "(impl)\\s+(binop)\\s+\\(((.*)\\s*:\\s*(.*))\\)(.*)\\(((.*)\\s*:\\s*(.*))\\)\\s*->\\s*(\\w+)\\s*\\{",
-      "end": "\\}",
-      "beginCaptures": {
-        "1": {
-          "name": "keyword.impl.reid"
-        },
-        "2": {
-          "name": "keyword.impl.reid"
-        },
-        "4": {
-          "name": "variable.parameter.binop.reid"
-        },
-        "5": {
-          "name": "entity.name.type.parameter.binop.reid"
-        },
-        "6": {
-          "name": "keyword.operator.math.reid"
-        },
-        "8": {
-          "name": "variable.parameter.binop.reid"
-        },
-        "9": {
-          "name": "entity.name.type.parameter.binop.reid"
-        },
-        "10": {
-          "name": "entity.name.type.return.binop.reid"
-        }
-      },
-      "patterns": [
-        {
-          "include": "#expression"
-        }
-      ]
-    },
    "struct-definition": {
-      "begin": "(struct)\\s*(\\w+)\\s*\\{",
-      "end": "\\}",
+      "match": "(struct)\\s*(\\w+)",
      "captures": {
        "1": {
          "name": "keyword.struct.reid"
@ -206,15 +100,10 @@
        "2": {
          "name": "entity.name.type"
        }
-      },
-      "patterns": [
-        {
-          "include": "#annotated-identifier"
-        }
-      ]
+      }
    },
    "struct-expression": {
-      "begin": "([A-Z]\\w*)\\s*\\{",
+      "begin": "\\b([A-Z]\\w*)\\s*\\{",
      "end": "\\}",
      "captures": {
        "1": {
@ -230,19 +119,19 @@
    "number-literal": {
      "patterns": [
        {
-          "match": "0x[0-9a-fA-F]+(\\.[0-9a-fA-F]+)?",
+          "match": "\\b0x[0-9a-fA-F]+(\\.[0-9a-fA-F]+)?\\b",
          "name": "constant.hexadecimal"
        },
        {
-          "match": "0o[0-7]+(\\.[0-7]+)?",
+          "match": "\\b0o[0-7]+(\\.[0-7]+)?\\b",
          "name": "constant.octal"
        },
        {
-          "match": "0b[01]+(\\.[01]+)?",
+          "match": "\\b0b[01]+(\\.[01]+)?\\b",
          "name": "constant.binary"
        },
        {
-          "match": "[0-9]+(\\.[0-9]+)?",
+          "match": "\\b[0-9]+(\\.[0-9]+)?\\b",
          "name": "constant.numeric"
        }
      ]
@ -253,25 +142,16 @@
      "name": "string.quoted.double",
      "patterns": [
        {
-          "match": "\\.",
+          "match": "\\\\\\w",
          "name": "constant.character.escape"
        }
      ]
    },
-    "block": {
-      "begin": "\\{",
-      "end": "\\}",
-      "patterns": [
-        {
-          "include": "#expression"
-        }
-      ]
-    },
    "namespace": {
      "match": "(\\w+)(\\:\\:)",
      "captures": {
        "1": {
-          "name": "entity.name.function.reid"
+          "name": "entity.name.namespace.reid"
        },
        "2": {
          "name": "keyword.operator.namespace.reid"
@ -290,11 +170,19 @@
      }
    },
    "function-call": {
-      "begin": "(\\w+)?\\(",
-      "end": "\\)",
+      "begin": "(\\w+)?(\\()",
+      "end": "(\\))",
      "beginCaptures": {
        "1": {
          "name": "entity.name.function.reid"
+        },
+        "2": {
+          "name": "punctuation.parenthesis.reid"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.parenthesis.reid"
        }
      },
      "patterns": [
@ -322,28 +210,10 @@
        }
      ]
    },
-    "annotated-identifier": {
-      "begin": "(\\w+)\\:",
-      "end": ",",
-      "beginCaptures": {
-        "1": {
-          "name": "variable.language.reid"
-        }
-      },
-      "patterns": [
-        {
-          "include": "#expression"
-        }
-      ]
-    },
    "identifier": {
      "patterns": [
        {
-          "match": "[A-Z]\\w*",
-          "name": "entity.name.type.reid"
-        },
-        {
-          "match": "\\w+",
+          "match": "\\b(?:\\w+)\\b",
          "name": "variable.language.reid"
        }
      ]
@ -351,16 +221,32 @@
    "keywords": {
      "patterns": [
        {
-          "match": "let|mut|pub|extern",
+          "match": "\\b(?:let|mut|pub|extern)\\b",
          "name": "storage.type.reid"
        },
        {
-          "match": "if|return",
+          "match": "\\bimport\\b",
+          "name": "keyword.import.reid"
+        },
+        {
+          "match": "\\bbinop\\b",
+          "name": "keyword.binop.reid"
+        },
+        {
+          "match": "\\bimpl\\b",
+          "name": "keyword.impl.reid"
+        },
+        {
+          "match": "\\b(?:if|return|for|in)\\b",
          "name": "keyword.control"
        },
        {
-          "match": "self",
+          "match": "\\bself\\b",
          "name": "variable.language.self.reid"
+        },
+        {
+          "match": "\\bfn\\b",
+          "name": "keyword.fn.reid"
        }
      ]
    },
@ -388,7 +274,7 @@
      ]
    },
    "common-type": {
-      "match": "u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|bool",
+      "match": "\\b(?:u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|f16|f16b|f32|f64|f80|f128|f128ppc|bool|char|([A-Z]\\w*))\\b",
      "name": "entity.name.type.common.reid"
    }
  }
--- a/reid-lsp/syntaxes/grammar.yaml
+++ b/reid-lsp/syntaxes/grammar.yaml
@ -1,133 +1,52 @@
 scopeName: source.reid
 patterns:
-  - include: "#import"
  - include: "#expression"
 repository:
-  # function-definition:
-  #   begin: "(fn)\\s*(\\w+)\\(((\\w+)\\s*\\:\\s*(\\w+),?)*\\)\\s*->\\s*(\\w+)\\s*\\{"
-  #   end: "\\}"
-  #   beginCaptures:
-  #     1:
-  #       name: "keyword.other"
-  #     2:
-  #       name: "entity.name.function"
-  #     4:
-  #       name: "entity.name.parameter"
-  #     5:
-  #       name: "entity.name.type"
-  #     6:
-  #       name: "entity.name.type"
-  #   patterns:
-  #     - include: "#type"
-  #     - include: "#expression"
-  import:
-    begin: "(import)\\s*"
-    end: ";"
-    beginCaptures:
-      1:
-        name: keyword
-    endCaptures:
-      0:
-        name: punctuation.semi.reid
+  expression:
    patterns:
+      - include: "#comment"
+      - include: "#fn-signature"
+      - include: "#namespace"
+      - include: "#common-type"
+      - include: "#struct-definition"
+      - include: "#binop"
+      - include: "#cast"
+      - include: "#function-call"
+      - include: "#parenthesis"
+      - include: "#array"
+      - include: "#keywords"
+      - include: "#number-literal"
+      - include: "#string-literal"
      - include: "#identifier"
-      - include: "#punctiation"
+      - include: "#punctuation"
  punctuation:
    patterns:
      - match: "::"
        name: keyword.operator.namespace.reid
+      - match: ":"
+        name: keyword.operator.colon.reid
      - match: ";"
        name: punctuation.semi.reid
      - match: "."
        name: punctuation.dot.reid
      - match: ","
        name: punctuation.comma.reid
-  expression:
-    patterns:
-      - include: "#comment"
-      - include: "#fn-signature"
-      - include: "#common-type"
-      - include: "#binop-impl"
-      - include: "#type-impl"
-      - include: "#struct-definition"
-      - include: "#block"
-      - include: "#binop"
-      - include: "#namespace"
-      - include: "#cast"
-      - include: "#function-call"
-      - include: "#parenthesis"
-      - include: "#array"
-      - include: "#keywords"
-      - include: "#struct-expression"
-      - include: "#number-literal"
-      - include: "#string-literal"
-      - include: "#identifier"
-      - include: "#punctuation"
+      - match: "\\{|\\}"
+        name: punctuation.brackets.curly.reid
+      - match: "\\(|\\)"
+        name: punctuation.parenthesis.reid
  comment:
    match: "\\/\\/(.|\\/)*"
    name: comment.line.double-slash.reid
-  fn-signature:
-    begin: "(fn)\\s*(\\w+)\\("
-    beginCaptures:
-      1:
-        name: keyword.fn.reid
-      2:
-        name: entity.name.function.reid
-    end: "\\)"
-    patterns:
-      - include: "#annotated-identifier"
-      - include: "#keywords"
-      - include: "#binop"
-    endCaptures:
-      2:
-        name: entity.name.type.reid
-  type-impl:
-    begin: >
-      (impl)\s*
-      (\w+)\s*
-      \{
-    end: "\\}"
-    captures:
-      1:
-        name: keyword.impl.reid
-      2:
-        name: entity.name.type
-    patterns:
-      - include: "#expression"
-  binop-impl:
-    begin: "(impl)\\s+(binop)\\s+\\(((.*)\\s*:\\s*(.*))\\)(.*)\\(((.*)\\s*:\\s*(.*))\\)\\s*->\\s*(\\w+)\\s*\\{"
-    end: "\\}"
-    beginCaptures:
-      1:
-        name: keyword.impl.reid
-      2:
-        name: keyword.impl.reid
-      4:
-        name: variable.parameter.binop.reid
-      5:
-        name: entity.name.type.parameter.binop.reid
-      6:
-        name: keyword.operator.math.reid
-      8:
-        name: variable.parameter.binop.reid
-      9:
-        name: entity.name.type.parameter.binop.reid
-      10:
-        name: entity.name.type.return.binop.reid
-    patterns:
-      - include: "#expression"
  struct-definition:
-    begin: "(struct)\\s*(\\w+)\\s*\\{"
-    end: "\\}"
+    match: "(struct)\\s*(\\w+)"
    captures:
      1:
        name: keyword.struct.reid
      2:
        name: entity.name.type
-    patterns:
-      - include: "#annotated-identifier"
  struct-expression:
-    begin: "([A-Z]\\w*)\\s*\\{"
+    begin: "\\b([A-Z]\\w*)\\s*\\{"
    end: "\\}"
    captures:
      1:
@ -136,31 +55,26 @@ repository:
      - include: "#expression"
  number-literal:
    patterns:
-      - match: "0x[0-9a-fA-F]+(\\.[0-9a-fA-F]+)?"
+      - match: "\\b0x[0-9a-fA-F]+(\\.[0-9a-fA-F]+)?\\b"
        name: "constant.hexadecimal"
-      - match: "0o[0-7]+(\\.[0-7]+)?"
+      - match: "\\b0o[0-7]+(\\.[0-7]+)?\\b"
        name: "constant.octal"
-      - match: "0b[01]+(\\.[01]+)?"
+      - match: "\\b0b[01]+(\\.[01]+)?\\b"
        name: "constant.binary"
-      - match: "[0-9]+(\\.[0-9]+)?"
+      - match: "\\b[0-9]+(\\.[0-9]+)?\\b"
        name: "constant.numeric"
  string-literal:
    begin: '"'
    end: '"'
    name: string.quoted.double
    patterns:
-      - match: "\\."
+      - match: "\\\\\\w"
        name: constant.character.escape
-  block:
-    begin: "\\{"
-    end: "\\}"
-    patterns:
-      - include: "#expression"
  namespace:
    match: "(\\w+)(\\:\\:)"
    captures:
      1:
-        name: entity.name.function.reid
+        name: entity.name.namespace.reid
      2:
        name: keyword.operator.namespace.reid
  cast:
@ -171,11 +85,16 @@ repository:
      2:
        name: entity.name.type.reid
  function-call:
-    begin: "(\\w+)?\\("
-    end: "\\)"
+    begin: "(\\w+)?(\\()"
+    end: "(\\))"
    beginCaptures:
      1:
        name: entity.name.function.reid
+      2:
+        name: punctuation.parenthesis.reid
+    endCaptures:
+      1:
+        name: punctuation.parenthesis.reid
    patterns:
      - include: "#expression"
  parenthesis:
@ -189,28 +108,26 @@ repository:
        name: keyword.operator.parenthesis.reid
    patterns:
      - include: "#expression"
-  annotated-identifier:
-    begin: "(\\w+)\\:"
-    end: ","
-    beginCaptures:
-      1:
-        name: variable.language.reid
-    patterns:
-      - include: "#expression"
  identifier:
    patterns:
-      - match: "[A-Z]\\w*"
-        name: entity.name.type.reid
-      - match: "\\w+"
+      - match: "\\b(?:\\w+)\\b"
        name: variable.language.reid
  keywords:
    patterns: 
-      - match: "let|mut|pub|extern"
-        name: "storage.type.reid"
-      - match: "if|return"
-        name: "keyword.control"
-      - match: "self"
-        name: "variable.language.self.reid"
+      - match: "\\b(?:let|mut|pub|extern)\\b"
+        name: storage.type.reid
+      - match: "\\bimport\\b"
+        name: keyword.import.reid
+      - match: "\\bbinop\\b"
+        name: keyword.binop.reid
+      - match: "\\bimpl\\b"
+        name: keyword.impl.reid
+      - match: "\\b(?:if|return|for|in)\\b"
+        name: keyword.control
+      - match: "\\bself\\b"
+        name: variable.language.self.reid
+      - match: "\\bfn\\b"
+        name: keyword.fn.reid
  binop:
    match: "\\<\\=|\\>\\=|\\=\\=|\\<|\\>|\\*|\\+|\\-|\\^|\\&\\&|\\&"
    name: keyword.operator.math.reid
@ -226,7 +143,7 @@ repository:
    patterns:
      - include: "#expression"
  common-type:
-    match: "u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|bool"
+    match: "\\b(?:u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|f16|f16b|f32|f64|f80|f128|f128ppc|bool|char|([A-Z]\\w*))\\b"
    name: entity.name.type.common.reid
  
    
--- a/reid/Cargo.toml
+++ b/reid/Cargo.toml
@ -1,21 +1,23 @@
 [package]
 name = "reid"
-version = "1.0.0-beta.2"
+version = "1.0.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html


 [features]
-default = ["color"]
+default = ["color", "cli"]

 color = ["colored"]
-log_output = []
-context_debug = []
+cli = ["argh", "stderrlog"]

 [dependencies]
 ## Make it easier to generate errors
 thiserror = "1.0.44"
-reid-lib = { path = "../reid-llvm-lib", version = "1.0.0-beta.1", registry="gitea-teascade" }
+reid-lib = { path = "../reid-llvm-lib", version = "1.0.0", registry="gitea-teascade" }

-colored = {version = "3.0.0", optional = true}
+argh = { version = "0.1.13", optional = true }
+stderrlog = { version = "0.6.0", optional = true }
+log = "*"
+colored = { version = "3.0.0", optional = true }
--- a/reid/examples/cli.rs
+++ b/reid/examples/cli.rs
@ -20,7 +20,6 @@ fn main() -> Result<(), std::io::Error> {
        let mir_path = parent.with_extension("mir");
        let asm_path = parent.with_extension("asm");

-        #[cfg(feature = "log_output")]
        let before = std::time::SystemTime::now();

        let text = fs::read_to_string(&path)?;
@ -38,35 +37,29 @@ fn main() -> Result<(), std::io::Error> {
                },
                CustomIRs { llir, mir },
            )) => {
-                #[cfg(feature = "log_output")]
-                {
-                    println!("{}", _llvm_ir);
-                    println!("Compiled with triple: {}\n", &_triple);
-                    println!("Output LLVM IR to {:?}", llvm_ir_path);
-                    println!("Output Assembly to {:?}", asm_path);
-                    println!("Output Object-file to {:?}\n", object_path);
-                    println!("Output LLIR-file to {:?}\n", llir_path);
-                    println!("Output MIR-file to {:?}\n", mir_path);
-                }
+                log::trace!("{}", _llvm_ir);
+                log::debug!("Compiled with triple: {}\n", &_triple);
+                log::debug!("Output LLVM IR to {:?}", llvm_ir_path);
+                log::debug!("Output Assembly to {:?}", asm_path);
+                log::debug!("Output Object-file to {:?}\n", object_path);
+                log::debug!("Output LLIR-file to {:?}\n", llir_path);
+                log::debug!("Output MIR-file to {:?}\n", mir_path);

                fs::write(&llvm_ir_path, &_llvm_ir).expect("Could not write LLVM IR -file!");
                fs::write(&asm_path, &assembly).expect("Could not write Assembly-file!");
                fs::write(&object_path, &obj_buffer).expect("Could not write Object-file!");
                fs::write(&llir_path, &llir).expect("Could not write LLIR-file!");
                fs::write(&mir_path, &mir).expect("Could not write MIR-file!");
-                #[cfg(feature = "log_output")]
-                {
-                    let after = std::time::SystemTime::now();
-                    println!(
-                        "Compilation took: {:.2}ms\n",
-                        (after.duration_since(before).unwrap().as_micros() as f32) / 1000.
-                    );
+                let after = std::time::SystemTime::now();
+                println!(
+                    "Compilation took: {:.2}ms\n",
+                    (after.duration_since(before).unwrap().as_micros() as f32) / 1000.
+                );

-                    println!("Linking {:?}", &object_path);
-                }
+                println!("Linking {:?}", &object_path);

                let linker = std::env::var("LD").unwrap_or("ld".to_owned());
-                let mut linker = LDRunner::from_command(&linker).with_library("c");
+                let mut linker = LDRunner::from_command(&linker).with_library("c").with_library("m");
                for library in libraries {
                    linker = linker.with_library(&library);
                }
@ -75,8 +68,7 @@ fn main() -> Result<(), std::io::Error> {
            Err(e) => panic!("{}", e),
        };
    } else {
-        #[cfg(feature = "log_output")]
-        println!("Please input compiled file path!")
+        log::error!("Please input compiled file path!")
    }
    Ok(())
 }
--- a/reid/lib/std.reid
+++ b/reid/lib/std.reid
@ -3,6 +3,7 @@ extern fn puts(message: *char) -> i32;
 extern fn free(ptr: *u8);
 extern fn div(numerator: i32, denominator: i32) -> div_t;

+/// Editable string value that can be printed and extended
 struct String {
    inner: *char,
    length: u64,
@ -11,6 +12,7 @@ struct String {
 }

 impl String {
+    /// Returns a new empty `String`-object, which must later be manually freed.
    pub fn new() -> String {
        String {
            inner: char::malloc(0),
@ -20,6 +22,8 @@ impl String {
        }
    }

+    /// Creates a new `String`-object containing initially data from the given
+    /// string-literal which must be later freed.
    pub fn from(str: *char) -> String {
        let length = str_length(str) as u64;
        let mut new = String::new();
@ -33,12 +37,14 @@ impl String {
        return new;
    }

+    /// Same as `concat`
    pub fn push(&mut self, other: String) {
        for i in 0 .. (str_length(other.inner) - 1) {
            add_char(self, other.inner[i]);
        }
    }

+    /// Adds a character to the end of this string
    pub fn add_char(&mut self, c: char) {
        if ((*self).length + 1) >= (*self).max_length {
            let new = char::malloc((*self).max_length + 4);
@ -57,6 +63,7 @@ impl String {
        (*self).length = (*self).length + 1;
    }

+    /// Formats the given number into the end of the string.
    pub fn push_num(&mut self, num: u64) {
        if num >= 10 {
            self.push_num(num / 10)
@ -75,18 +82,22 @@ impl String {
        else if rem == 9 { self.add_char('9'); }
    }

+    /// Concatenates `source` to the end of `destination`.
    pub fn concat(&mut self, other: &String) {
        for i in 0 .. *other.length {
            self.add_char(*other.inner[i]);
        }
    }

+    /// Edits given `string` by setting the character at index `position` to be
+    /// `c`.
    pub fn set(&mut self, c: char, position: u64) {
        if position <= (*self).length {
            (*self).inner[position] = c;
        }
    }

+    /// Frees this given string
    pub fn free(&self) {
        free((*self).inner as *u8);
    }
@ -111,14 +122,17 @@ struct div_t {
    remainder: i32,
 }

+/// Print given string to stdout
 pub fn print(message: String) {
    puts(message.inner);
 }

+/// Divide an integer, returning the quotient and remainder.
 pub fn int_div(numerator: i32, denominator: i32) -> div_t {
    return div(numerator, denominator);
 }

+/// (deprecated) creates a new editable string
 pub fn new_string() -> String {
    String {
        inner: char::malloc(0),
@ -128,6 +142,8 @@ pub fn new_string() -> String {
    }
 }

+/// Creates a new `String`-object containing initially data from the given
+/// string-literal which must be later freed.
 pub fn from_str(str: *char) -> String {
    let length = str_length(str) as u64;
    let mut new = new_string();
@ -141,6 +157,7 @@ pub fn from_str(str: *char) -> String {
    return new;
 }

+/// (deprecated) Adds a character to the end of a given string
 pub fn add_char(string: &mut String, c: char) {
    if ((*string).length + 1) >= (*string).max_length {
        let new = char::malloc((*string).max_length + 4);
@ -159,12 +176,14 @@ pub fn add_char(string: &mut String, c: char) {
    (*string).length = (*string).length + 1;
 }

+/// (deprecated) sets a character in a string
 pub fn set_char(string: &mut String, c: char, position: u64) {
    if position <= (*string).length {
        (*string).inner[position] = c;
    }
 }

+/// (deprecated) frees given string
 pub fn free_string(string: &String) {
    free((*string).inner as *u8);
 }
@ -183,6 +202,7 @@ fn str_length(string: *char) -> u32 {
    return pos + 1;
 }

+/// (deprecated) concatenates number to the end of this string.
 pub fn add_num_to_str(string: &mut String, num: u64) {
    if num >= 10 {
        add_num_to_str(string, num / 10)
@ -201,12 +221,15 @@ pub fn add_num_to_str(string: &mut String, num: u64) {
    else if rem == 9 { add_char(string, '9'); }
 }

+/// (deprecated) concatenates two strings to the destination
 pub fn concat_strings(destination: &mut String, source: String) {
    for i in 0 .. (str_length(source.inner) - 1) {
        add_char(destination, source.inner[i]);
    }
 }

+/// Returns `value` as clamped between `min` and `max`. Equivalent to
+/// `max(min(value, max), min)`
 pub fn clamp(min: f32, max: f32, value: f32) -> f32 {
    if value > max {
        return max;
@ -217,6 +240,7 @@ pub fn clamp(min: f32, max: f32, value: f32) -> f32 {
    return value;
 }

+/// Returns the absolute value of `value`.
 pub fn abs(f: f32) -> f32 {
    if f < 0.0 {
        return f * (0.0 - 1.0);
--- a/reid/src/ast/lexer.rs
+++ b/reid/src/ast/lexer.rs
@ -116,6 +116,7 @@ pub enum Token {

    Whitespace(String),
    Comment(String),
+    Doc(String),
    Eof,
 }

@ -196,6 +197,7 @@ impl ToString for Token {
            Token::Percent => String::from('%'),
            Token::Whitespace(val) => val.clone(),
            Token::Comment(val) => format!("//{}", val.clone()),
+            Token::Doc(val) => format!("///{}", val.clone()),
            Token::Unknown(val) => val.to_string(),
        }
    }
@ -309,13 +311,25 @@ pub fn tokenize<T: Into<String>>(to_tokenize: T) -> Result<Vec<FullToken>, Error
            }
            // Comments
            '/' if cursor.first() == Some('/') => {
+                cursor.next();
+                let doc = if cursor.first() == Some('/') {
+                    cursor.next();
+                    true
+                } else {
+                    false
+                };
+
                let mut comment = String::new();
                while !matches!(cursor.first(), Some('\n') | None) {
                    if let Some(c) = cursor.next() {
                        comment.push(c);
                    }
                }
-                Token::Comment(comment)
+                if doc {
+                    Token::Doc(comment)
+                } else {
+                    Token::Comment(comment)
+                }
            }
            '\"' | '\'' => {
                let mut value = String::new();
--- a/reid/src/ast/mod.rs
+++ b/reid/src/ast/mod.rs
@ -1,7 +1,7 @@
 //! This is the module that contains relevant code to parsing Reid, that is to
 //! say transforming a Vec of FullTokens into a loose parsed AST that can be
 //! used for unwrapping syntax sugar, and then be transformed into Reid MIR.
-use std::{fs::Metadata, path::PathBuf};
+use std::path::PathBuf;

 use token_stream::TokenRange;

@ -184,7 +184,7 @@ pub struct LetStatement {
 }

 #[derive(Debug, Clone)]
-pub struct ImportStatement(pub Vec<String>, pub TokenRange);
+pub struct ImportStatement(pub Vec<(String, TokenRange)>, pub TokenRange);

 #[derive(Debug)]
 pub struct FunctionDefinition(pub FunctionSignature, pub bool, pub Block, pub TokenRange);
@ -192,6 +192,7 @@ pub struct FunctionDefinition(pub FunctionSignature, pub bool, pub Block, pub To
 #[derive(Debug, Clone)]
 pub struct FunctionSignature {
    pub name: String,
+    pub documentation: Option<String>,
    pub self_kind: SelfKind,
    pub params: Vec<(String, Type, TokenRange)>,
    pub return_type: Option<Type>,
@ -207,7 +208,7 @@ pub enum SelfKind {
    None,
 }

-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ReturnType {
    Soft,
    Hard,
@ -272,9 +273,9 @@ pub enum TopLevelStatement {

 #[derive(Debug)]
 pub struct BinopDefinition {
-    pub lhs: (String, Type),
+    pub lhs: (String, Type, TokenRange),
    pub op: BinaryOperator,
-    pub rhs: (String, Type),
+    pub rhs: (String, Type, TokenRange),
    pub return_ty: Type,
    pub block: Block,
    pub signature_range: TokenRange,
--- a/reid/src/ast/parse.rs
+++ b/reid/src/ast/parse.rs
@ -175,7 +175,50 @@ impl Parse for AssociatedFunctionCall {
        let ty = stream.parse()?;
        stream.expect(Token::Colon)?;
        stream.expect(Token::Colon)?;
-        Ok(AssociatedFunctionCall(ty, stream.parse()?))
+
+        if stream.next_is_whitespace() {
+            stream.expecting_err_nonfatal("associated function name");
+            return Ok(AssociatedFunctionCall(
+                ty,
+                FunctionCallExpression {
+                    name: String::new(),
+                    params: Vec::new(),
+                    range: stream.get_range_prev_curr().unwrap(),
+                    is_macro: false,
+                },
+            ));
+        }
+
+        match stream.parse() {
+            Ok(fn_call) => Ok(AssociatedFunctionCall(ty, fn_call)),
+            _ => {
+                if let Some(Token::Identifier(fn_name)) = stream.peek() {
+                    stream.next();
+                    stream.expected_err_nonfatal("associated function call");
+
+                    Ok(AssociatedFunctionCall(
+                        ty,
+                        FunctionCallExpression {
+                            name: fn_name,
+                            params: Vec::new(),
+                            range: stream.get_range_prev_curr().unwrap(),
+                            is_macro: false,
+                        },
+                    ))
+                } else {
+                    stream.expected_err_nonfatal("associated function name");
+                    Ok(AssociatedFunctionCall(
+                        ty,
+                        FunctionCallExpression {
+                            name: String::new(),
+                            params: Vec::new(),
+                            range: stream.get_range_prev_curr().unwrap(),
+                            is_macro: false,
+                        },
+                    ))
+                }
+            }
+        }
    }
 }

@ -244,9 +287,9 @@ impl Parse for PrimaryExpression {
                stream.get_range().unwrap(),
            )
        } else if let Some(Token::Star) = stream.peek() {
-            stream.next(); // Consume Et
+            stream.next(); // Consume Star
            apply_inner(stream.parse()?, |e| {
-                Expression(Kind::Deref(Box::new(e.0)), stream.get_range().unwrap())
+                Expression(Kind::Deref(Box::new(e.0.clone())), e.0 .1)
            })
        } else if let Ok(unary) = stream.parse() {
            Expression(
@ -467,7 +510,7 @@ fn parse_binop_rhs(
            if curr_token_prec < next_prec {
                // Operator on the right of rhs has more precedence, turn
                // rhs into lhs for new binop
-                rhs = parse_binop_rhs(stream, rhs, Some(op))?;
+                rhs = stream.parse_with(|mut st| parse_binop_rhs(&mut st, rhs, Some(op)))?;
            } else {
                let _ = prev_operator.insert(next_op);
            }
@ -610,7 +653,7 @@ impl Parse for LetStatement {
            stream.expect(Token::Equals)?;

            let expression = stream.parse()?;
-            stream.expect(Token::Semi)?;
+            stream.expect_nonfatal(Token::Semi).ok();
            Ok(LetStatement {
                name: variable,
                ty,
@ -631,19 +674,21 @@ impl Parse for ImportStatement {
        let mut import_list = Vec::new();

        if let Some(Token::Identifier(name)) = stream.next() {
-            import_list.push(name);
+            import_list.push((name, stream.get_range_prev_curr().unwrap()));
            while stream.expect(Token::Colon).is_ok() && stream.expect(Token::Colon).is_ok() {
-                if let Some(Token::Identifier(name)) = stream.next() {
-                    import_list.push(name);
+                if let Some(Token::Identifier(name)) = stream.peek() {
+                    stream.next(); // Consume identifier
+                    import_list.push((name, stream.get_range_prev_curr().unwrap()));
                } else {
-                    Err(stream.expected_err("identifier")?)?
+                    stream.expected_err_nonfatal("identifier");
+                    break;
                }
            }
        } else {
            Err(stream.expected_err("identifier")?)?
        }

-        stream.expect(Token::Semi)?;
+        stream.expect_nonfatal(Token::Semi).ok();

        Ok(ImportStatement(import_list, stream.get_range().unwrap()))
    }
@ -651,6 +696,8 @@ impl Parse for ImportStatement {

 impl Parse for FunctionDefinition {
    fn parse(mut stream: TokenStream) -> Result<Self, Error> {
+        let documentation = stream.find_documentation();
+
        let is_pub = if let Some(Token::PubKeyword) = stream.peek() {
            stream.next(); // Consume pub
            true
@ -659,8 +706,10 @@ impl Parse for FunctionDefinition {
        };

        stream.expect(Token::FnKeyword)?;
+        let mut signature: FunctionSignature = stream.parse()?;
+        signature.documentation = documentation;
        Ok(FunctionDefinition(
-            stream.parse()?,
+            signature,
            is_pub,
            stream.parse()?,
            stream.get_range().unwrap(),
@ -765,6 +814,7 @@ impl Parse for FunctionSignature {

            Ok(FunctionSignature {
                name,
+                documentation: None,
                params,
                self_kind,
                return_type,
@ -788,7 +838,7 @@ impl Parse for Block {
                // if semicolon is missing.
                if !matches!(e, Expression(ExpressionKind::IfExpr(_), _)) {
                    // In theory could ignore the missing semicolon..
-                    return Err(stream.expected_err("semicolon to complete statement")?);
+                    stream.expected_err_nonfatal("semicolon to complete statement");
                }

                statements.push(BlockLevelStatement::Expression(e));
@ -906,7 +956,8 @@ pub enum DotIndexKind {
 impl Parse for DotIndexKind {
    fn parse(mut stream: TokenStream) -> Result<Self, Error> {
        stream.expect(Token::Dot)?;
-        if let Some(Token::Identifier(name)) = stream.next() {
+        if let Some(Token::Identifier(name)) = stream.peek() {
+            stream.next(); // Consume identifer
            if let Ok(args) = stream.parse::<FunctionArgs>() {
                Ok(Self::FunctionCall(FunctionCallExpression {
                    name,
@ -915,10 +966,18 @@ impl Parse for DotIndexKind {
                    is_macro: false,
                }))
            } else {
-                Ok(Self::StructValueIndex(name, stream.get_range().unwrap()))
+                Ok(Self::StructValueIndex(name, stream.get_range_prev().unwrap()))
            }
        } else {
-            return Err(stream.expected_err("struct index (number)")?);
+            if stream.next_is_whitespace() {
+                stream.expecting_err_nonfatal("struct index");
+                Ok(Self::StructValueIndex(
+                    String::new(),
+                    stream.get_range_prev_curr().unwrap(),
+                ))
+            } else {
+                Err(stream.expecting_err("struct index")?)
+            }
        }
    }
 }
@ -932,7 +991,7 @@ impl Parse for BlockLevelStatement {
            Some(Token::ReturnKeyword) => {
                stream.next();
                let exp = stream.parse().ok();
-                stream.expect(Token::Semi)?;
+                stream.expect_nonfatal(Token::Semi).ok();
                Stmt::Return(ReturnType::Hard, exp)
            }
            Some(Token::For) => {
@ -997,7 +1056,7 @@ impl Parse for SetStatement {
        let var_ref = stream.parse()?;
        stream.expect(Token::Equals)?;
        let expr = stream.parse()?;
-        stream.expect(Token::Semi)?;
+        stream.expect_nonfatal(Token::Semi).ok();
        Ok(SetStatement(var_ref, expr, stream.get_range().unwrap()))
    }
 }
@ -1035,10 +1094,13 @@ impl Parse for TopLevelStatement {
        Ok(match stream.peek() {
            Some(Token::ImportKeyword) => Stmt::Import(stream.parse()?),
            Some(Token::Extern) => {
+                let documentation = stream.find_documentation();
                stream.next(); // Consume Extern
                stream.expect(Token::FnKeyword)?;
-                let extern_fn = Stmt::ExternFunction(stream.parse()?);
-                stream.expect(Token::Semi)?;
+                let mut signature: FunctionSignature = stream.parse()?;
+                signature.documentation = documentation;
+                let extern_fn = Stmt::ExternFunction(signature);
+                stream.expect_nonfatal(Token::Semi).ok();
                extern_fn
            }
            Some(Token::FnKeyword) | Some(Token::PubKeyword) => Stmt::FunctionDefinition(stream.parse()?),
@ -1072,6 +1134,7 @@ impl Parse for BinopDefinition {
        let Some(Token::Identifier(lhs_name)) = stream.next() else {
            return Err(stream.expected_err("lhs name")?);
        };
+        let lhs_range = stream.get_range_prev_curr().unwrap();
        stream.expect(Token::Colon)?;
        let lhs_type = stream.parse()?;
        stream.expect(Token::ParenClose)?;
@ -1082,6 +1145,7 @@ impl Parse for BinopDefinition {
        let Some(Token::Identifier(rhs_name)) = stream.next() else {
            return Err(stream.expected_err("rhs name")?);
        };
+        let rhs_range = stream.get_range_prev_curr().unwrap();
        stream.expect(Token::Colon)?;
        let rhs_type = stream.parse()?;
        stream.expect(Token::ParenClose)?;
@ -1091,9 +1155,9 @@ impl Parse for BinopDefinition {
        stream.expect(Token::Arrow)?;

        Ok(BinopDefinition {
-            lhs: (lhs_name, lhs_type),
+            lhs: (lhs_name, lhs_type, lhs_range),
            op: operator,
-            rhs: (rhs_name, rhs_type),
+            rhs: (rhs_name, rhs_type, rhs_range),
            return_ty: stream.parse()?,
            block: stream.parse()?,
            signature_range,
@ -1114,11 +1178,11 @@ impl Parse for AssociatedFunctionBlock {
            match stream.peek() {
                Some(Token::FnKeyword) | Some(Token::PubKeyword) => {
                    let mut fun: FunctionDefinition = stream.parse()?;
-                    fun.0.self_kind = match fun.0.self_kind {
-                        SelfKind::Owned(_) => SelfKind::Owned(ty.clone()),
-                        SelfKind::Borrow(_) => SelfKind::Borrow(ty.clone()),
-                        SelfKind::MutBorrow(_) => SelfKind::MutBorrow(ty.clone()),
-                        SelfKind::None => SelfKind::None,
+                    match &mut fun.0.self_kind {
+                        SelfKind::Owned(inner_ty) => inner_ty.0 = ty.0.clone(),
+                        SelfKind::Borrow(inner_ty) => inner_ty.0 = ty.0.clone(),
+                        SelfKind::MutBorrow(inner_ty) => inner_ty.0 = ty.0.clone(),
+                        SelfKind::None => {}
                    };
                    functions.push(fun);
                }
--- a/reid/src/ast/process.rs
+++ b/reid/src/ast/process.rs
@ -1,7 +1,7 @@
 use std::path::PathBuf;

 use crate::{
-    ast::{self},
+    ast::{self, ReturnType},
    mir::{
        self, CustomTypeKey, FunctionParam, ModuleMap, NamedVariableRef, ReturnKind, SourceModuleId, StmtKind,
        StructField, StructType, WhileStatement,
@ -30,12 +30,20 @@ impl ast::Module {
        for stmt in &self.top_level_statements {
            match stmt {
                Import(import) => {
-                    imports.push(mir::Import(import.0.clone(), import.1.as_meta(module_id)));
+                    imports.push(mir::Import(
+                        import
+                            .0
+                            .iter()
+                            .map(|(s, range)| (s.clone(), range.as_meta(module_id)))
+                            .collect(),
+                        import.1.as_meta(module_id),
+                    ));
                }
                FunctionDefinition(function_def) => functions.push(function_def.into_mir(module_id)),
                ExternFunction(signature) => {
                    let def = mir::FunctionDefinition {
                        name: signature.name.clone(),
+                        documentation: signature.documentation.clone(),
                        linkage_name: None,
                        is_pub: false,
                        is_imported: false,
@ -56,6 +64,7 @@ impl ast::Module {
                            .collect(),
                        kind: mir::FunctionDefinitionKind::Extern(false),
                        source: Some(module_id),
+                        signature_meta: signature.range.as_meta(module_id),
                    };
                    functions.push(def);
                }
@ -96,13 +105,13 @@ impl ast::Module {
                        lhs: mir::FunctionParam {
                            name: lhs.0.clone(),
                            ty: lhs.1 .0.into_mir(module_id),
-                            meta: lhs.1 .1.as_meta(module_id),
+                            meta: lhs.2.as_meta(module_id),
                        },
                        op: op.mir(),
                        rhs: mir::FunctionParam {
                            name: rhs.0.clone(),
                            ty: rhs.1 .0.into_mir(module_id),
-                            meta: rhs.1 .1.as_meta(module_id),
+                            meta: rhs.2.as_meta(module_id),
                        },
                        return_type: return_ty.0.into_mir(module_id),
                        fn_kind: mir::FunctionDefinitionKind::Local(
@ -168,6 +177,7 @@ impl ast::FunctionDefinition {
        }));
        mir::FunctionDefinition {
            name: signature.name.clone(),
+            documentation: signature.documentation.clone(),
            linkage_name: None,
            is_pub: *is_pub,
            is_imported: false,
@ -179,6 +189,7 @@ impl ast::FunctionDefinition {
            parameters: params,
            kind: mir::FunctionDefinitionKind::Local(block.into_mir(module_id), (range).as_meta(module_id)),
            source: Some(module_id),
+            signature_meta: signature.range.as_meta(module_id),
        }
    }
 }
@ -226,8 +237,9 @@ impl ast::Block {
                    );
                    let let_statement = mir::Statement(
                        StmtKind::Let(counter_var.clone(), true, start.process(module_id)),
-                        counter_range.as_meta(module_id),
+                        start.1.as_meta(module_id),
                    );
+                    let statement_range = counter_range.clone() + start.1 + end.1 + block.2;

                    let set_new = mir::Statement(
                        StmtKind::Set(
@ -253,8 +265,33 @@ impl ast::Block {
                        ),
                        counter_range.as_meta(module_id),
                    );
-                    let mut block = block.into_mir(module_id);
-                    block.statements.push(set_new);
+
+                    let mir_block = if let Some((ret_kind, ret_expr)) = &block.1 {
+                        if *ret_kind == ReturnType::Soft {
+                            if let Some(ret_expr) = ret_expr {
+                                let mir_ret = ret_expr.process(module_id);
+                                let mut clone = block.clone();
+                                clone.1 = None;
+                                let mut mir_block = clone.into_mir(module_id);
+                                mir_block
+                                    .statements
+                                    .push(mir::Statement(StmtKind::Expression(mir_ret.clone()), mir_ret.1));
+                                mir_block.statements.push(set_new);
+                                mir_block
+                            } else {
+                                let mut mir_block = block.into_mir(module_id);
+                                mir_block.statements.push(set_new);
+                                mir_block
+                            }
+                        } else {
+                            block.into_mir(module_id)
+                        }
+                    } else {
+                        let mut mir_block = block.into_mir(module_id);
+                        mir_block.statements.push(set_new);
+                        mir_block
+                    };
+
                    let while_statement = mir::Statement(
                        StmtKind::While(WhileStatement {
                            condition: mir::Expression(
@ -267,23 +304,23 @@ impl ast::Block {
                                    Box::new(end.process(module_id)),
                                    mir::TypeKind::Vague(mir::VagueType::Unknown),
                                ),
-                                counter_range.as_meta(module_id),
+                                end.1.as_meta(module_id),
                            ),
-                            block,
-                            meta: self.2.as_meta(module_id),
+                            block: mir_block.clone(),
+                            meta: (*counter_range + end.1 + block.2).as_meta(module_id),
                        }),
-                        self.2.as_meta(module_id),
+                        (*counter_range + end.1 + block.2).as_meta(module_id),
                    );

                    let inner_scope = StmtKind::Expression(mir::Expression(
                        mir::ExprKind::Block(mir::Block {
                            statements: vec![let_statement, while_statement],
                            return_expression: None,
-                            meta: counter_range.as_meta(module_id) + end.1.as_meta(module_id),
+                            meta: statement_range.as_meta(module_id),
                        }),
-                        counter_range.as_meta(module_id) + end.1.as_meta(module_id),
+                        statement_range.as_meta(module_id),
                    ));
-                    (inner_scope, self.2)
+                    (inner_scope, statement_range)
                }
                ast::BlockLevelStatement::WhileLoop(expression, block) => (
                    StmtKind::While(WhileStatement {
@ -291,7 +328,7 @@ impl ast::Block {
                        block: block.into_mir(module_id),
                        meta: self.2.as_meta(module_id),
                    }),
-                    self.2,
+                    expression.1 + block.2,
                ),
            };

@ -371,7 +408,7 @@ impl ast::Expression {
                Box::new(idx_expr.process(module_id)),
            ),
            ast::ExpressionKind::StructExpression(struct_init) => mir::ExprKind::Struct(
-                struct_init.name.clone(),
+                CustomTypeKey(struct_init.name.clone(), module_id),
                struct_init
                    .fields
                    .iter()
@ -546,7 +583,7 @@ impl ast::TypeKind {
            }
            ast::TypeKind::Ptr(type_kind) => mir::TypeKind::UserPtr(Box::new(type_kind.clone().into_mir(source_mod))),
            ast::TypeKind::F16 => mir::TypeKind::F16,
-            ast::TypeKind::F32B => mir::TypeKind::F32B,
+            ast::TypeKind::F32B => mir::TypeKind::F16B,
            ast::TypeKind::F32 => mir::TypeKind::F32,
            ast::TypeKind::F64 => mir::TypeKind::F64,
            ast::TypeKind::F80 => mir::TypeKind::F80,
--- a/reid/src/ast/token_stream.rs
+++ b/reid/src/ast/token_stream.rs
@ -1,6 +1,8 @@
 //! Contains relevant code for parsing tokens received from
 //! Lexing/Tokenizing-stage.

+use std::{cell::RefCell, rc::Rc};
+
 use crate::{
    ast::parse::Parse,
    lexer::{FullToken, Token},
@ -12,6 +14,7 @@ use crate::{
 pub struct TokenStream<'a, 'b> {
    ref_position: Option<&'b mut usize>,
    tokens: &'a [FullToken],
+    errors: Rc<RefCell<Vec<Error>>>,
    pub position: usize,
 }

@ -20,6 +23,7 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        TokenStream {
            ref_position: None,
            tokens,
+            errors: Rc::new(RefCell::new(Vec::new())),
            position: 0,
        }
    }
@ -38,6 +42,16 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        ))
    }

+    /// Returns expected-error for the next token in-line. Useful in conjunction
+    /// with [`TokenStream::peek`]
+    pub fn expected_err_nonfatal<T: Into<String>>(&mut self, expected: T) {
+        let err = match self.expected_err(expected) {
+            Ok(e) => e,
+            Err(e) => e,
+        };
+        self.errors.borrow_mut().push(err);
+    }
+
    /// Returns expected-error for the previous token that was already consumed.
    /// Useful in conjunction with [`TokenStream::next`]
    pub fn expecting_err<T: Into<String>>(&mut self, expected: T) -> Result<Error, Error> {
@ -50,6 +64,16 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        ))
    }

+    /// Returns expected-error for the previous token that was already consumed.
+    /// Useful in conjunction with [`TokenStream::next`]
+    pub fn expecting_err_nonfatal<T: Into<String>>(&mut self, expected: T) {
+        let err = match self.expecting_err(expected) {
+            Ok(e) => e,
+            Err(e) => e,
+        };
+        self.errors.borrow_mut().push(err);
+    }
+
    pub fn expect(&mut self, token: Token) -> Result<(), Error> {
        if let (pos, Some(peeked)) = self.next_token(self.position) {
            if token == peeked.token {
@ -63,6 +87,42 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        }
    }

+    pub fn find_documentation(&mut self) -> Option<String> {
+        let mut from = self.position;
+        let mut documentation = None;
+        while let Some(token) = self.tokens.get(from) {
+            if matches!(token.token, Token::Whitespace(_) | Token::Comment(_) | Token::Doc(_)) {
+                from += 1;
+                if let Token::Doc(doctext) = &token.token {
+                    documentation = Some(
+                        match documentation {
+                            Some(t) => t + " ",
+                            None => String::new(),
+                        } + doctext.trim(),
+                    );
+                }
+            } else {
+                break;
+            }
+        }
+        documentation
+    }
+
+    pub fn expect_nonfatal(&mut self, token: Token) -> Result<(), ()> {
+        if let (pos, Some(peeked)) = self.next_token(self.position) {
+            if token == peeked.token {
+                self.position = pos + 1;
+                Ok(())
+            } else {
+                self.expecting_err_nonfatal(token);
+                Err(())
+            }
+        } else {
+            self.expecting_err_nonfatal(token);
+            Err(())
+        }
+    }
+
    pub fn next(&mut self) -> Option<Token> {
        let (position, token) = self.next_token(self.position);
        self.position = position + 1;
@ -147,6 +207,7 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        let clone = TokenStream {
            ref_position: Some(&mut ref_pos),
            tokens: self.tokens,
+            errors: self.errors.clone(),
            position,
        };

@ -159,6 +220,29 @@ impl<'a, 'b> TokenStream<'a, 'b> {
        }
    }

+    pub fn parse_with<T, U>(&mut self, fun: T) -> Result<U, Error>
+    where
+        T: FnOnce(TokenStream) -> Result<U, Error>,
+    {
+        let mut ref_pos = self.position;
+
+        let position = self.position;
+        let clone = TokenStream {
+            ref_position: Some(&mut ref_pos),
+            tokens: self.tokens,
+            errors: self.errors.clone(),
+            position,
+        };
+
+        match fun(clone) {
Author	SHA1	Message	Date
sofia	fbbaf09f73	Update version number for lsp-extension	2025-09-07 15:56:41 +03:00
sofia	4cb0ce9d69	Update reid-llvm-lib	2025-09-07 15:40:22 +03:00
sofia	5a65f7912f	Update version to 1.0.0	2025-09-07 15:39:53 +03:00
sofia	c04dc01258	Add reid-llvm-lib as submodule	2025-09-07 15:35:10 +03:00
sofia	d5a4168b0d	Remove reid-llvm-lib, move to own git repo	2025-09-07 15:34:22 +03:00
sofia	663f327ccf	Make small tweaks to lsp extension	2025-08-17 19:36:02 +03:00
sofia	84233c8f49	Add reid.png	2025-08-17 18:13:11 +03:00
sofia	07b0403e9b	Make exit code propagate	2025-08-17 17:48:40 +03:00
sofia	28934ea6fc	Add run-subcommand	2025-08-17 17:44:44 +03:00
sofia	7dd06567bb	Make some logs better	2025-08-17 17:33:11 +03:00
sofia	77107ef95e	Fix a bunch of warnings	2025-08-17 17:19:03 +03:00
sofia	1d0fd9dd0a	Change all previous weird logs to log:: logs	2025-08-17 17:16:58 +03:00
sofia	3a5766186a	Add main.rs and make usage a little nicer	2025-08-17 17:07:19 +03:00
sofia	8d8d6ac336	Clean up grammar by a lot	2025-08-17 16:22:06 +03:00
sofia	fa95da97ae	Remove unused debug-logs	2025-08-16 17:38:29 +03:00
sofia	407c681cb6	Add ordering for how types are chosen for binops	2025-08-16 17:36:37 +03:00
sofia	2dd482c9c2	Fix for-loop generation	2025-08-16 16:25:08 +03:00
sofia	1a5823c59c	Add failing loop edge case example	2025-08-16 16:14:24 +03:00
sofia	3ebe16b80b	Fix docs for associated function calls	2025-08-14 17:59:17 +03:00
sofia	7a6f99479a	Add documentation to function autocompletes	2025-08-14 17:48:49 +03:00
sofia	f4bce14299	Add documentation for intrinsics	2025-08-14 17:45:07 +03:00
sofia	aa1de16f4c	Add documentation to std	2025-08-14 17:34:08 +03:00
sofia	89b6fc1a71	Improve invoked ty hover	2025-08-14 17:10:56 +03:00
sofia	ceee2f286a	Improve function hover texts	2025-08-14 17:05:32 +03:00
sofia	dcb4e76a40	Add documentation to hovers	2025-08-14 16:52:45 +03:00
sofia	6dccab8b12	Add hover kind	2025-08-14 16:39:31 +03:00
sofia	7b4f38406d	Add some initial documentation support for functions	2025-08-14 16:28:33 +03:00
sofia	9e37ae7aac	Re-add equals for floats	2025-08-14 14:40:14 +03:00
sofia	3e0367fb1e	Disallow == between floats	2025-08-13 12:54:41 +03:00
sofia	685520a6cf	Fix floating-point modulo	2025-08-13 12:47:50 +03:00
sofia	0203213b28	Fix a bunch of errors in reid-llvm-lib	2025-08-12 21:21:10 +03:00
sofia	c23160bc32	Fix inconsitent multiple typedefs	2025-08-12 21:02:32 +03:00
sofia	fe6fe6c435	Fix linker setting types as dependencies when they are also dependencies	2025-08-12 20:47:27 +03:00
sofia	3e85ed2705	Remove unnecessary dbg!	2025-08-12 20:35:28 +03:00
sofia	d50a748884	Add contributes breakpoints	2025-08-08 16:20:22 +03:00
sofia	c44d588b30	Fix a1.reid	2025-08-08 16:01:26 +03:00
sofia	0e23ab4636	Add back a type in linker that I thought unnecessary	2025-08-07 21:40:57 +03:00
sofia	ce2473a715	Add is_null to documentation	2025-08-07 21:33:50 +03:00
sofia	1a8535516c	Add nullptr comparison	2025-08-07 21:32:30 +03:00
sofia	e1ac019ecd	Fix codegen typedef sorting, again, oops	2025-08-07 18:43:21 +03:00
sofia	82b67dfaaa	Fix typedef ordering in codegen	2025-08-06 22:01:28 +03:00
sofia	a5c7823a29	Resolve types recursively instead of just on-surface	2025-08-06 21:36:33 +03:00
sofia	3dba4a79ff	Move one type resolution to a better place	2025-08-06 21:04:31 +03:00
sofia	2a8842658d	Fix linker type importing	2025-08-06 21:01:05 +03:00
sofia	8d32f2bbad	Add a lot more references to types in places	2025-08-05 23:57:45 +03:00
sofia	0ee9d3bf7d	Fix linker type-replacement for imported functions	2025-08-05 22:23:57 +03:00
sofia	1dd4bbbb05	Fix lsp compilation problem	2025-08-05 22:04:02 +03:00
sofia	8cbc65422e	Fix more warnings	2025-08-05 22:03:14 +03:00
sofia	3cd4121951	Fix linker cyclical fields checker	2025-08-05 22:02:19 +03:00
sofia	c84954480b	Fix loads of warnings	2025-08-05 22:00:11 +03:00
sofia	67106ea17b	Fix struct gep naming in LLVM	2025-08-05 21:57:07 +03:00
sofia	015c111b29	Fix modules needing to be evaluated in order in codegen	2025-08-05 21:55:04 +03:00
sofia	aad3c93068	Fix imports not setting their importer-value correctly	2025-08-05 21:45:40 +03:00
sofia	1ba0de442a	Fix linker working with recursive imports	2025-08-05 21:03:53 +03:00
sofia	1c3386bc9a	Fix triple-importing	2025-08-04 23:46:46 +03:00
sofia	8a178387ca	Allow initializing foreign structs as well	2025-08-04 22:33:06 +03:00
sofia	b93b7aa52b	Fix struct fields not being linked correctly for foreign types	2025-08-04 22:24:03 +03:00
sofia	1275063dc2	Pass associated functions as well as functions	2025-08-04 22:09:26 +03:00
sofia	02522dd36d	Fix typechecker crashing unexpectedly with vague type	2025-08-04 21:18:14 +03:00
sofia	5b7c3d5b3a	Cleanup	2025-08-04 21:14:32 +03:00
sofia	70a968d7a0	Add sqrt	2025-08-04 19:48:14 +03:00
sofia	a9d5a4d03b	Fix token ranges for for-loops	2025-08-04 18:37:19 +03:00
sofia	11d93e4adf	Fix length-intrinsic	2025-08-04 18:12:01 +03:00
sofia	c2f6cfb8e6	Update intrinsics documentation	2025-08-04 18:02:28 +03:00
sofia	34612e98ce	Add documentation about memcpy-intrinsic	2025-08-04 17:52:03 +03:00
sofia	3b4835cff8	Fix and add memcpy-intrinsic	2025-08-04 17:51:32 +03:00
sofia	627d1bcfa5	Add a large amount of new intrinsics	2025-08-04 17:51:32 +03:00
sofia	ae6796acfc	Fix calling convention for integers/real-numbers	2025-08-04 17:51:32 +03:00
sofia	5d19d38682	Add intrinsic min/max to integers and floats	2025-08-04 17:51:32 +03:00
sofia	4a33e7d123	Fix binop parsing from last commit	2025-08-04 17:51:32 +03:00
sofia	79ecb3b9ba	Fix token-ranges for derefs and binop rhs	2025-08-04 14:30:36 +03:00
sofia	28157ae4b8	Bump version numbers	2025-08-04 00:43:13 +03:00
sofia	8d27a6e7bd	Fix reference-linking for local functions	2025-08-04 00:41:44 +03:00
sofia	136e9f9d1f	Update readme	2025-08-04 00:21:10 +03:00
sofia	8e41deb653	Add compile-on-save	2025-08-04 00:13:10 +03:00
sofia	766a853b48	Add refactoring and go-to-definition for multifile	2025-08-04 00:07:31 +03:00
sofia	109fedb624	Make get-references work for multifiles	2025-08-03 23:54:49 +03:00
sofia	d27ec2bb70	Add StateMap	2025-08-03 22:44:00 +03:00
sofia	5706fd99e3	Move a bunch of fields to AnalysisState instead	2025-08-03 22:37:28 +03:00
sofia	3b3b21d4dc	Add possibility to pre-define module-ids	2025-08-03 22:32:31 +03:00
sofia	7809aeb2b5	Add source module id for symbols	2025-08-03 21:51:04 +03:00
sofia	cd2ebb5224	Add refactoring	2025-08-03 21:45:48 +03:00
sofia	8b0d09c08d	Fix find-all-references	2025-08-03 21:34:44 +03:00
sofia	a215a2116a	Add reference-finding	2025-08-03 21:29:40 +03:00
sofia	0abeb0c4cd	Flatten a pyramid with a helper function	2025-08-03 21:15:47 +03:00
sofia	ac0d79f816	add trivial semantic tokens	2025-08-03 21:11:04 +03:00
sofia	909728a564	Fix type selection for properties	2025-08-03 21:02:05 +03:00
sofia	82537224e7	Add go-to-definition	2025-08-03 20:57:56 +03:00
sofia	79b3c6b3ef	Fix custom struct field definition semantic tokens	2025-08-03 20:27:31 +03:00
sofia	1ae164b1d6	Fix assoc function symbols	2025-08-03 20:24:34 +03:00
sofia	9b9baabc81	Add associated function symbols	2025-08-03 20:03:31 +03:00
sofia	13c462cb9b	Add Type and Struct semantic tokens someplaces	2025-08-03 19:49:56 +03:00
sofia	8739fe16d1	Add property semantic tokens	2025-08-03 19:46:04 +03:00
sofia	1438ba7bd1	Add semantic highlighting for binop params	2025-08-03 19:39:40 +03:00
sofia	d9911a8ff5	Fix TokenRange for assoc function self	2025-08-03 19:27:54 +03:00
sofia	48dd17b320	Fix parameter symbols for extern functions	2025-08-03 19:15:48 +03:00
sofia	dcc53498e7	Add definition and reference modifiers	2025-08-03 19:01:51 +03:00
sofia	018f3e2561	Fix function signature meta for extern functions	2025-08-03 18:45:27 +03:00
sofia	6a9133baff	Add semantic highlighting to variable references	2025-08-03 18:32:35 +03:00
sofia	3f3de9e2c0	Clean up some duplicate .max'es	2025-08-03 18:19:50 +03:00
sofia	b965ca11b9	Add semantic highlighting for let-statements	2025-08-03 18:17:21 +03:00
sofia	3537318466	Refactor analysis a little bit	2025-08-03 16:21:10 +03:00
sofia	dbc43f51ee	Add language configuration	2025-08-03 15:52:12 +03:00
sofia	c7f1b81c9d	Improve associated functions so you can now call them on numbers too	2025-08-03 01:33:52 +03:00
sofia	a51a2c8f56	Remove useless prints	2025-08-03 01:00:30 +03:00
sofia	101ee2d8e5	Account for intrinsic associated functions with autocomplete	2025-08-03 01:00:02 +03:00
sofia	a6844b919b	Fix array_structs.reid	2025-08-03 00:16:47 +03:00
sofia	4ea0913842	Add autocomplete for associated functions and struct fields	2025-08-03 00:13:53 +03:00
sofia	bb9f69ee53	Add autocomplete for imports	2025-08-02 23:03:11 +03:00
sofia	97a5c3a65e	Optimize LSP analysis a Lot	2025-08-02 21:47:20 +03:00
sofia	8595da0c30	Make LSP use a more general analysis structure	2025-08-02 21:11:33 +03:00
sofia	dae39bc9d2	Fix fibonacci.reid	2025-08-02 20:21:57 +03:00
sofia	658450993a	Fix hover types for for-loops	2025-08-02 20:10:48 +03:00
sofia	3f6d26679d	Update README.md, all TODOs done	2025-08-02 19:24:31 +03:00
sofia	16082752e2	Update language server client and configs	2025-08-02 19:19:29 +03:00
sofia	8a71ce3629	Update LSP client	2025-08-02 15:02:39 +03:00
sofia	81d418c6d8	Update version number	2025-08-02 14:36:56 +03:00
				`@ -0,0 +1 @@`
				`Subproject commit 100cd96a6dc3bb882ce60e78c4eab47e77fdd8c4`