Add imported_type to e2e-tests

Update readme, clean up a little
Fix bug in custom binops where their return types aren't inferred
2025-07-26 14:05:06 +03:00 · 2025-07-26 14:04:24 +03:00 · 2025-07-26 14:01:53 +03:00 · 2025-07-26 13:18:55 +03:00 · 2025-07-26 12:56:42 +03:00 · 2025-07-26 01:34:37 +03:00
21 changed files with 467 additions and 792 deletions
--- a/README.md
+++ b/README.md
@ -49,8 +49,8 @@ Currently missing big features (TODOs) are:
 - ~~Debug Information~~ (DONE)
 - ~~Fix struct initialization (wrong order and missing fields allowed now)~~
 - ~~Not-Unary~~
- Importing types from other modules
- Importable binops?
+- ~~Importing types from other modules~~
+- ~~Importable binops?~~
 - Associated functions (for e.g. sizeof)

 Big features that I want later but are not necessary:
--- a/examples/a.reid
+++ b/examples/a.reid
@ -1,6 +0,0 @@
-pub fn abs(f: f32) -> f32 {
-    if f < 0.0 {
-        return f * (0.0 - 1.0);
-    }
-    return f;
-}
--- a/examples/imported_type.reid
+++ b/examples/imported_type.reid
@ -0,0 +1,9 @@
+
+import std::print;
+import std::from_str;
+import std::String;
+
+fn main() -> u8 {
+    print(from_str("hello") + " beep: " + 1234u64);
+    return 0;
+}
--- a/examples/testmod.reid
+++ b/examples/testmod.reid
@ -0,0 +1,10 @@
+
+struct Otus {}
+
+impl binop (lhs: Otus) + (rhs: u64) -> Otus {
+    return lhs;
+}
+
+pub fn make_otus() -> Otus {
+    return Otus {};
+}
--- a/foo.reid
+++ b/foo.reid
@ -1,469 +0,0 @@
-import std::concat_strings;
-import std::print;
-import std::from_str;
-import std::free_string;
-import std::add_num_to_str;
-
-///////////////////
-/// SDL externs ///
-///////////////////
-
-// Helper struct for stack allocated const sized strings, because structs are
-// easier to create uninit than arrays.
-struct SDL_Window {}
-struct SDL_Renderer {}
-struct SDL_Texture {}
-struct SDL_Event { type: u32, reserved: [u8; 124] }
-struct SDL_FRect { x: f32, y: f32, w: f32, h: f32 }
-struct SDL_Rect { x: i32, y: i32, w: i32, h: i32 }
-extern fn SDL_malloc(size: u64) -> *u8;
-extern fn SDL_Init(flags: u32) -> bool;
-extern fn SDL_Quit();
-extern fn SDL_CreateWindowAndRenderer(title: *char, width: i32, height: i32, flags: i32,
-    window_out: &mut *SDL_Window, renderer_out: &mut *SDL_Renderer) -> bool;
-extern fn SDL_Delay(ms: u32);
-extern fn SDL_SetRenderDrawColor(renderer: *SDL_Renderer, r: u8, g: u8, b: u8, a: u8);
-extern fn SDL_RenderClear(renderer: *SDL_Renderer);
-extern fn SDL_RenderPresent(renderer: *SDL_Renderer);
-extern fn SDL_HasEvent(event_type: u32) -> bool;
-extern fn SDL_PollEvent(event: &mut SDL_Event) -> bool;
-extern fn SDL_PumpEvents();
-extern fn SDL_FlushEvents(min_type: u32, max_type: u32);
-extern fn SDL_GetTicks() -> u64;
-extern fn SDL_SetWindowTitle(window: *SDL_Window, title: *char) -> bool;
-extern fn SDL_CreateTexture(renderer: *SDL_Renderer, 
-    pixel_format: u32, texture_access: u32, width: u32, height: u32) -> *SDL_Texture;
-extern fn SDL_RenderTexture(renderer: *SDL_Renderer,
-    texture: *SDL_Texture, srcfrect: &SDL_FRect, dstfrect: &SDL_FRect) -> bool;
-extern fn SDL_UpdateTexture(texture: *SDL_Texture, rect: &SDL_Rect, pixels: *u8, pitch: u32) -> bool;
-extern fn SDL_GetError() -> *char;
-extern fn SDL_GetWindowSize(window: *SDL_Window, w: &mut i32, h: &mut i32) -> bool;
-extern fn SDL_rand(max_exclusive: u32) -> u32;
-extern fn SDL_SetTextureScaleMode(texture: *SDL_Texture, scale_mode: i32) -> bool;
-extern fn SDL_sqrtf(value: f32) -> f32;
-extern fn SDL_randf() -> f32;
-extern fn SDL_powf(value: f32, power: f32) -> f32;
-
-// SDL error reporting helper
-fn print_sdl_error(context: *char) {
-    let mut message = from_str(context);
-
-    let delim = from_str(": ");
-    concat_strings(&mut message, delim);
-    free_string(&delim);
-
-    let error_msg = from_str(SDL_GetError());
-    concat_strings(&mut message, error_msg);
-    free_string(&error_msg);
-
-    print(message);
-
-    free_string(&message);
-}
-
-/////////////////////////////////
-/// Main setup and frame loop ///
-/////////////////////////////////
-
-struct GameState {
-    renderer: *SDL_Renderer,
-    window: *SDL_Window,
-    render_texture: *SDL_Texture,
-    frame_counter: u32,
-    last_fps_reset: u64,
-    pixels: *u8,
-    pixels_w: u32,
-    pixels_h: u32,
-    pixels_bpp: u32,
-}
-
-fn main() -> i32 {
-    let SDL_INIT_VIDEO = 32;
-    let SDL_WINDOW_RESIZABLE = 32;
-    let SDL_PIXELFORMAT_RGBA8888 = 373694468;
-    let SDL_PIXELFORMAT_ABGR8888 = 376840196;
-    let SDL_PIXELFORMAT_RGB24 = 386930691;
-    let SDL_PIXELFORMAT_BGR24 = 390076419;
-    let SDL_PIXELFORMAT_RGB96_FLOAT = 454057996;
-    let SDL_PIXELFORMAT_BGR96_FLOAT = 457203724;
-    let SDL_TEXTUREACCESS_STREAMING = 1;
-    let SDL_SCALEMODE_NEAREST = 0;
-    let SDL_SCALEMODE_LINEAR = 1;
-    let SDL_SCALEMODE_PIXELART = 2;
-
-    let init_success = SDL_Init(SDL_INIT_VIDEO);
-    if init_success == false {
-        print_sdl_error("SDL init failed");
-        return 1;
-    }
-
-    let mut window = SDL_malloc(1) as *SDL_Window;
-    let mut renderer = SDL_malloc(1) as *SDL_Renderer;
-    let gfx_init_success = SDL_CreateWindowAndRenderer(
-        "graphical reid program", 640, 480, SDL_WINDOW_RESIZABLE,
-        &mut window, &mut renderer
-    );
-    if gfx_init_success == false {
-        print_sdl_error("SDL renderer and window creation failed");
-        return 1;
-    }
-
-    let width = 320;
-    let height = 240;
-    let bpp = 4;
-    let render_texture = SDL_CreateTexture(renderer, 
-        SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, width, height);
-    SDL_SetTextureScaleMode(render_texture, SDL_SCALEMODE_NEAREST);
-
-    let pixels_len = (width * height * bpp) as u64;
-    let pixels = SDL_malloc(pixels_len);
-    let mut game_state = GameState {
-        renderer: renderer,
-        window: window,
-        render_texture: render_texture,
-        frame_counter: 0,
-        last_fps_reset: 0,
-        pixels: pixels,
-        pixels_w: width,
-        pixels_h: height,
-        pixels_bpp: bpp,
-    };
-
-    while frame_loop(&mut game_state) {}
-
-    SDL_Quit();
-    return 0;
-}
-
-fn frame_loop(game_state: &mut GameState) -> bool {
-    let mut event = SDL_Event {};
-    while (SDL_PollEvent(&mut event)) {
-        if event.type == 256 { // SDL_EVENT_QUIT
-            return false;
-        }
-    }
-
-    let mut screen_width = 0;
-    let mut screen_height = 0;
-    SDL_GetWindowSize(*game_state.window, &mut screen_width, &mut screen_height);
-
-    let renderer = *game_state.renderer;
-    SDL_SetRenderDrawColor(renderer, 0, 50, 90, 255);
-    SDL_RenderClear(renderer);
-
-    let w = *game_state.pixels_w;
-    let h = *game_state.pixels_h;
-    let bpp = *game_state.pixels_bpp;
-    for y in 0..h {
-        for x in 0..w {
-            render_pixel(x, y, game_state);
-        }
-    }
-
-    let texture_area = SDL_Rect { x: 0, y: 0, w: w as i32, h: h as i32 };
-    if SDL_UpdateTexture(*game_state.render_texture, &texture_area, *game_state.pixels as *u8, bpp * w) == false {
-        print_sdl_error("UpdateTexture error");
-    }
-    let src = SDL_FRect { x: 0.0, y: 0.0, w: w as f32, h: h as f32 };
-    let aspect_ratio = src.w / src.h;
-    let scaled_width = screen_height as f32 * aspect_ratio;
-    let dst = SDL_FRect { x: (screen_width as f32 - scaled_width) / 2.0, y: 0.0, w: scaled_width, h: screen_height as f32 };
-    if SDL_RenderTexture(renderer, *game_state.render_texture, &src, &dst) == false {
-        print_sdl_error("RenderTexture error");
-    }
-
-    SDL_RenderPresent(renderer);
-    SDL_Delay(1);
-
-    *game_state.frame_counter = *game_state.frame_counter + 1;
-    let t = SDL_GetTicks();
-    if (t - *game_state.last_fps_reset) >= 1000 {
-        let mut title = from_str("graphical reid program ");
-        add_num_to_str(&mut title, *game_state.frame_counter as u64);
-        let fps_unit = from_str(" fps");
-        concat_strings(&mut title, fps_unit);
-        free_string(&fps_unit);
-        SDL_SetWindowTitle(*game_state.window, title.inner);
-        free_string(&title);
-        *game_state.frame_counter = 0;
-        *game_state.last_fps_reset = t;
-    }
-
-    return true;
-}
-
-fn render_pixel(x: u32, y: u32, game_state: &mut GameState) {
-    let w = *game_state.pixels_w;
-    let h = *game_state.pixels_h;
-    let bpp = *game_state.pixels_bpp;
-
-    let samples = 1;
-    let old_sample_weight = 0.75;
-    let new_sample_weight = 0.25 / samples as f32;
-    let mut rgb = vec_mul_scalar(old_sample_weight, [
-        srgb_to_linear(*game_state.pixels[(x + y * w) * bpp + 0]),
-        srgb_to_linear(*game_state.pixels[(x + y * w) * bpp + 1]),
-        srgb_to_linear(*game_state.pixels[(x + y * w) * bpp + 2])
-    ]);
-    for sample in 0..samples {
-        rgb = vec_add(rgb, vec_mul_scalar(new_sample_weight, shade(x, y, *game_state.frame_counter, w, h)));
-    }
-    *game_state.pixels[(x + y * w) * bpp + 0] = linear_to_srgb(rgb[0]);
-    *game_state.pixels[(x + y * w) * bpp + 1] = linear_to_srgb(rgb[1]);
-    *game_state.pixels[(x + y * w) * bpp + 2] = linear_to_srgb(rgb[2]);
-    *game_state.pixels[(x + y * w) * bpp + 3] = 255;
-}
-
-
-/////////////////
-/// Rendering ///
-/////////////////
-
-struct Ray {
-    origin: [f32; 3],
-    direction: [f32; 3],
-}
-
-struct Material {
-    // 0 = lambertian diffuse
-    // 1 = mirror
-    type: u32,
-    // Generally the "color" of the surface (linear factors of how much of each
-    // color channel this surface does not absorb), but the idea is that the
-    // type governs what this means.
-    linear_color: [f32; 3],
-}
-
-struct Hit {
-    hit: bool,
-    front_face: bool,
-    distance: f32,
-    normal: [f32; 3],
-    position: [f32; 3],
-    material: Material,
-}
-
-struct Sphere {
-    center: [f32; 3],
-    radius: f32,
-    material: Material,
-}
-
-fn shade(x: u32, y: u32, t: u32, w: u32, h: u32) -> [f32; 3] {
-    let jitter_x = SDL_randf() - 0.5;
-    let jitter_y = SDL_randf() - 0.5;
-
-    let pixel_scale = 1.0 / h as f32;
-    let pixel_pos = [
-        (x as f32 + jitter_x) * pixel_scale, 
-        1.0 - (y as f32 + jitter_y) * pixel_scale,
-        0.0 - 1.0
-    ];
-    let camera_pos = [w as f32 * 0.5f32 * pixel_scale, h as f32 * 0.5f32 * pixel_scale, 0.0f32];
-    let dir = vec_normalize(vec_sub(pixel_pos, camera_pos));
-    let ray = Ray { origin: camera_pos, direction: dir };
-    let beige_lambertian = Material { type: 0, linear_color: [0.3, 0.2, 0.1] };
-    let green_lambertian = Material { type: 0, linear_color: [0.1, 0.5, 0.06] };
-    let greenish_mirror = Material { type: 1, linear_color: [0.9, 1.0, 0.95] };
-    let spheres = [
-        // Ground
-        Sphere { center: vec_sub(camera_pos, [0.0, 100001.0, 0.0]), radius: 100000.0, material: beige_lambertian },
-        // Centered unit sphere
-        Sphere { center: vec_add(camera_pos, [0.0, 0.0, 0.0 - 5.0]), radius: 1.0, material: green_lambertian },
-        // The unit sphere on the right
-        Sphere { center: vec_add(camera_pos, [2.0, 0.0, 0.0 - 6.0]), radius: 1.0, material: greenish_mirror }
-    ];
-    return shade_world(ray, &spheres, 3);
-}
-
-fn shade_world(ray: Ray, spheres: &[Sphere; 3], bounces_left: u8) -> [f32; 3] {
-    if bounces_left == 0 {
-        return [0.0, 0.0, 0.0];
-    }
-
-    let ray_distance = 100.0;
-    let mut closest_hit = Hit { hit: false, front_face: false, distance: ray_distance };
-    for i in 0..3 {
-        let sphere_hit = ray_sphere_closest_hit(ray, *spheres[i], [0.001, closest_hit.distance]);
-        if sphere_hit.hit {
-            closest_hit = sphere_hit;
-        }
-    }
-
-    if closest_hit.hit {
-        //return vec_mul_scalar(0.5, vec_add(closest_hit.normal, [1.0, 1.0, 1.0])); // normal
-        //return vec_mul_scalar(closest_hit.distance / 10.0, [1.0, 1.0, 1.0]); // depth
-        if closest_hit.material.type == 0 {
-            let bounce_dir = vec_normalize(vec_add(closest_hit.normal, random_unit_vec()));
-            let bounce_ray = Ray { origin: closest_hit.position, direction: bounce_dir };
-            return vec_mul_componentwise(
-                closest_hit.material.linear_color, 
-                shade_world(bounce_ray, spheres, bounces_left - 1)
-            );
-        } else if closest_hit.material.type == 1 {
-            let bounce_dir = vec_reflect(ray.direction, closest_hit.normal);
-            let bounce_ray = Ray { origin: closest_hit.position, direction: bounce_dir };
-            return vec_mul_componentwise(
-                closest_hit.material.linear_color, 
-                shade_world(bounce_ray, spheres, bounces_left - 1)
-            );
-        } else {
-            return [1.0, 0.0, 1.0];
-        }
-    }
-
-    return shade_sky(ray);
-}
-
-fn shade_sky(ray: Ray) -> [f32; 3] {
-    let a = 0.5 * (ray.direction[1] + 1.0);
-    return vec_add(
-        vec_mul_scalar(1.0 - a, [1.0, 1.0, 1.0]),
-        vec_mul_scalar(a, [0.5, 0.7, 1.0])
-    );
-}
-
-// Returns the distance from the ray origin to the sphere, or -1.0 if the ray doesn't hit.
-fn ray_sphere_closest_hit(ray: Ray, sphere: Sphere, interval: [f32; 2]) -> Hit {
-    let to_sphere = vec_sub(sphere.center, ray.origin);
-    let h = vec_dot(ray.direction, to_sphere);
-    let c = vec_length_squared(to_sphere) - sphere.radius * sphere.radius;
-    let discriminant = h * h - c;
-    if discriminant < 0.0 {
-        return Hit { hit: false };
-    }
-
-    let discriminant_sqrt = SDL_sqrtf(discriminant);
-    let mut distance = h - discriminant_sqrt;
-    if interval_surrounds(interval, distance) == false {
-        distance = h - discriminant_sqrt;
-        if interval_surrounds(interval, distance) == false {
-            return Hit { hit: false };
-        }
-    }
-    let hit_position = vec_add(ray.origin, vec_mul_scalar(distance, ray.direction));
-    let mut front_face = true;
-    let mut normal = vec_normalize(vec_sub(hit_position, sphere.center));
-    if vec_dot(normal, ray.direction) > 0.0 {
-        normal = vec_mul_scalar(0.0 - 1.0, normal);
-        front_face = false;
-    }
-
-    return Hit {
-        hit: true, 
-        front_face: front_face,
-        distance: distance,
-        normal: normal,
-        position: hit_position,
-        material: sphere.material,
-    };
-}
-
-
-//////////////////
-/// Other math ///
-//////////////////
-
-fn clamp(min: f32, max: f32, value: f32) -> f32 {
-    if value > max {
-        return max;
-    }
-    if value < min {
-        return min;
-    }
-    return value;
-}
-
-fn abs(f: f32) -> f32 {
-    if f < 0.0 {
-        return f * (0.0 - 1.0);
-    }
-    return f;
-}
-
-fn vec_add(lhs: [f32; 3], rhs: [f32; 3]) -> [f32; 3] {
-    return [lhs[0] + rhs[0], lhs[1] + rhs[1], lhs[2] + rhs[2]];
-}
-
-fn vec_sub(lhs: [f32; 3], rhs: [f32; 3]) -> [f32; 3] {
-    return [lhs[0] - rhs[0], lhs[1] - rhs[1], lhs[2] - rhs[2]];
-}
-
-fn vec_dot(lhs: [f32; 3], rhs: [f32; 3]) -> f32 {
-    return lhs[0] * rhs[0] + lhs[1] * rhs[1] + lhs[2] * rhs[2];
-}
-
-fn vec_mul_componentwise(lhs: [f32; 3], rhs: [f32; 3]) -> [f32; 3] {
-    return [lhs[0] * rhs[0], lhs[1] * rhs[1], lhs[2] * rhs[2]];
-}
-
-fn vec_mul_scalar(lhs: f32, rhs: [f32; 3]) -> [f32; 3] {
-    return [lhs * rhs[0], lhs * rhs[1], lhs * rhs[2]];
-}
-
-fn vec_normalize(v: [f32; 3]) -> [f32; 3] {
-    let len_reciprocal = 1.0f32 / SDL_sqrtf(vec_length_squared(v));
-    return vec_mul_scalar(len_reciprocal, v);
-}
-
-fn vec_length_squared(v: [f32; 3]) -> f32 {
-    return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
-}
-
-fn vec_abs(v: [f32; 3]) -> [f32; 3] {
-    return [abs(v[0]), abs(v[1]), abs(v[2])];
-}
-
-fn vec_reflect(direction: [f32; 3], normal: [f32; 3]) -> [f32; 3] {
-    return vec_sub(direction, vec_mul_scalar(2.0f32 * vec_dot(direction, normal), normal));
-}
-
-fn interval_surrounds(interval: [f32; 2], value: f32) -> bool {
-    return (interval[0] < value) && (value < interval[1]);
-}
-
-fn random_unit_vec() -> [f32; 3] {
-    let mut point = [
-        SDL_randf() * 2.0f32 - 1.0f32,
-        SDL_randf() * 2.0f32 - 1.0f32,
-        SDL_randf() * 2.0f32 - 1.0f32
-    ];
-    let mut lensq = vec_length_squared(point);
-    while lensq > 1.0 {
-        point = [
-            SDL_randf() * 2.0f32 - 1.0f32,
-            SDL_randf() * 2.0f32 - 1.0f32,
-            SDL_randf() * 2.0f32 - 1.0f32
-        ];
-        lensq = vec_length_squared(point);
-    }
-    let len_reciprocal = 1.0f32 / SDL_sqrtf(lensq);
-    return vec_mul_scalar(len_reciprocal, point);
-}
-
-fn random_unit_vec_on_hemi(normal: [f32; 3]) -> [f32; 3] {
-    let rand_vec = random_unit_vec();
-    if vec_dot(rand_vec, normal) < 0.0f32 {
-        return vec_mul_scalar(0.0f32 - 1.0f32, rand_vec);
-    }
-    return rand_vec;
-}
-
-fn linear_to_srgb(linear: f32) -> u8 {
-    let mut floating_srgb = 0.0;
-    if linear <= 0.0031308f32 {
-        floating_srgb = 12.92f32 * linear;
-    } else {
-        floating_srgb = SDL_powf(linear as f32, 1.0 / 2.4) * 1.055f32 - 0.055f32;
-    }
-    let clamped = clamp(0.0, 1.0, floating_srgb);
-    return (clamped * 255.999) as u8;
-}
-
-fn srgb_to_linear(srgb: u8) -> f32 {
-    let floating_srgb = srgb as f32 / 255.0;
-    if floating_srgb <= 0.04045f32 {
-        return floating_srgb / 12.92f32;
-    }
-    return SDL_powf((floating_srgb as f32 + 0.055) / 1.055, 2.4);
-}
--- a/reid-llvm-lib/src/lib.rs
+++ b/reid-llvm-lib/src/lib.rs
@ -5,9 +5,7 @@
 use std::{fmt::Debug, marker::PhantomData};

 use builder::{BlockValue, Builder, FunctionValue, InstructionValue, ModuleValue, TypeValue};
-use debug_information::{
-    DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue,
-};
+use debug_information::{DebugFileData, DebugInformation, DebugLocationValue, DebugMetadataValue, DebugProgramValue};
 use fmt::PrintableModule;

 pub mod builder;
@ -66,13 +64,7 @@ pub struct Module<'ctx> {
 }

 impl<'ctx> Module<'ctx> {
-    pub fn function(
-        &self,
-        name: &str,
-        ret: Type,
-        params: Vec<Type>,
-        flags: FunctionFlags,
-    ) -> Function<'ctx> {
+    pub fn function(&self, name: &str, ret: Type, params: Vec<Type>, flags: FunctionFlags) -> Function<'ctx> {
        unsafe {
            Function {
                phantom: PhantomData,
@ -111,10 +103,7 @@ impl<'ctx> Module<'ctx> {
        }
    }

-    pub fn create_debug_info(
-        &mut self,
-        file: DebugFileData,
-    ) -> (DebugInformation, DebugProgramValue) {
+    pub fn create_debug_info(&mut self, file: DebugFileData) -> (DebugInformation, DebugProgramValue) {
        let (debug_info, program_value) = DebugInformation::from_file(file);
        self.debug_info = Some(debug_info.clone());
        (debug_info, program_value)
@ -144,10 +133,17 @@ pub struct FunctionData {

 #[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,
 }

@ -260,11 +256,7 @@ impl Instr {
 }

 impl<'builder> Block<'builder> {
-    pub fn build_named<T: Into<String>>(
-        &mut self,
-        name: T,
-        instruction: Instr,
-    ) -> CompileResult<InstructionValue> {
+    pub fn build_named<T: Into<String>>(&mut self, name: T, instruction: Instr) -> CompileResult<InstructionValue> {
        unsafe {
            self.builder.add_instruction(
                &self.value,
@ -295,15 +287,13 @@ impl<'builder> Block<'builder> {

    pub fn set_instr_location(&self, instruction: InstructionValue, location: DebugLocationValue) {
        unsafe {
-            self.builder
-                .add_instruction_location(&instruction, location);
+            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);
+            self.builder.add_instruction_metadata(&instruction, location);
        }
    }

@ -610,16 +600,10 @@ impl Type {
            | Type::U32
            | Type::U64
            | Type::U128 => TypeCategory::Integer,
-            Type::F16
-            | Type::F32B
-            | Type::F32
-            | Type::F64
-            | Type::F80
-            | Type::F128
-            | Type::F128PPC => TypeCategory::Real,
-            Type::Bool | Type::Void | Type::CustomType(_) | Type::Array(_, _) | Type::Ptr(_) => {
-                TypeCategory::Other
+            Type::F16 | Type::F32B | Type::F32 | Type::F64 | Type::F80 | Type::F128 | Type::F128PPC => {
+                TypeCategory::Real
            }
+            Type::Bool | Type::Void | Type::CustomType(_) | Type::Array(_, _) | Type::Ptr(_) => TypeCategory::Other,
        }
    }

@ -630,23 +614,15 @@ impl Type {
            (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()))
-            }
+            (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()))
-            }
+            (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) => {
@ -667,15 +643,11 @@ impl Type {
            (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()))
-            }
+            (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()))
-            }
+            (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())),
--- a/reid/lib/std.reid
+++ b/reid/lib/std.reid
@ -4,6 +4,27 @@ extern fn malloc(size: u64) -> *u8;
 extern fn free(ptr: *u8);
 extern fn div(numerator: i32, denominator: i32) -> div_t;

+struct String {
+    inner: *char,
+    length: u64,
+    max_length: u64,
+    must_be_freed: bool,
+}
+
+impl binop (lhs: String) + (rhs: *char) -> String {
+    let mut new = lhs;
+    let added = from_str(rhs);
+    concat_strings(&mut new, added);
+    free_string(&added);
+    return new;
+}
+
+impl binop (lhs: String) + (rhs: u64) -> String {
+    let mut new = lhs;
+    add_num_to_str(&mut new, rhs);
+    return new;
+}
+
 struct div_t {
    quotient: i32,
    remainder: i32,
@ -21,13 +42,6 @@ pub fn allocate(size: u64) -> *u8 {
    malloc(size)
 }

-struct String {
-    inner: *char,
-    length: u64,
-    max_length: u64,
-    must_be_freed: bool,
-}
-
 pub fn new_string() -> String {
    String {
        inner: allocate(0),
--- a/reid/src/ast/process.rs
+++ b/reid/src/ast/process.rs
@ -95,6 +95,7 @@ impl ast::Module {
                        },
                        meta: (*range).as_meta(module_id),
                        source_module: module_id,
+                        importer: None,
                    };
                    typedefs.push(def);
                }
@ -116,6 +117,7 @@ impl ast::Module {
                            block.2.as_meta(module_id),
                        ),
                        meta: signature_range.as_meta(module_id),
+                        exported: false,
                    });
                }
            }
--- a/reid/src/codegen/intrinsics.rs
+++ b/reid/src/codegen/intrinsics.rs
@ -49,6 +49,7 @@ where
        return_type: ty.clone(),
        fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicSimpleInstr(fun))),
        meta: Default::default(),
+        exported: false,
    }
 }

@ -63,6 +64,7 @@ where
        return_type: TypeKind::Bool,
        fn_kind: FunctionDefinitionKind::Intrinsic(Box::new(IntrinsicBooleanInstr(fun))),
        meta: Default::default(),
+        exported: false,
    }
 }

--- a/reid/src/codegen/mod.rs
+++ b/reid/src/codegen/mod.rs
@ -15,7 +15,7 @@ use scope::*;

 use crate::{
    mir::{
-        self, implement::TypeCategory, pass::ScopeBinopKey, CustomTypeKey, FunctionDefinitionKind, NamedVariableRef,
+        self, implement::TypeCategory, pass::BinopKey, CustomTypeKey, FunctionDefinitionKind, NamedVariableRef,
        SourceModuleId, StructField, StructType, TypeDefinition, TypeDefinitionKind, TypeKind, WhileStatement,
    },
    util::try_all,
@ -214,8 +214,12 @@ impl mir::Module {

        let mut binops = HashMap::new();
        for binop in &self.binop_defs {
+            let binop_fn_name = format!(
+                "binop.{}.{:?}.{}.{}",
+                binop.lhs.1, binop.op, binop.rhs.1, binop.return_type
+            );
            binops.insert(
-                ScopeBinopKey {
+                BinopKey {
                    params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
                    operator: binop.op,
                },
@ -224,16 +228,14 @@ impl mir::Module {
                    return_ty: binop.return_type.clone(),
                    kind: match &binop.fn_kind {
                        FunctionDefinitionKind::Local(block, metadata) => {
-                            let binop_fn_name = format!(
-                                "binop.{}.{:?}.{}.{}",
-                                binop.lhs.1, binop.op, binop.rhs.1, binop.return_type
-                            );
                            let ir_function = module.function(
                                &binop_fn_name,
                                binop.return_type.get_type(&type_values),
                                vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
                                FunctionFlags {
                                    inline: true,
+                                    is_pub: binop.exported,
+                                    is_imported: binop.exported,
                                    ..Default::default()
                                },
                            );
@ -289,7 +291,18 @@ impl mir::Module {

                            StackBinopFunctionKind::UserGenerated(ir_function)
                        }
-                        FunctionDefinitionKind::Extern(_) => todo!(),
+                        FunctionDefinitionKind::Extern(imported) => {
+                            StackBinopFunctionKind::UserGenerated(module.function(
+                                &binop_fn_name,
+                                binop.return_type.get_type(&type_values),
+                                vec![binop.lhs.1.get_type(&type_values), binop.rhs.1.get_type(&type_values)],
+                                FunctionFlags {
+                                    is_extern: true,
+                                    is_imported: *imported,
+                                    ..FunctionFlags::default()
+                                },
+                            ))
+                        }
                        FunctionDefinitionKind::Intrinsic(intrinsic_function) => {
                            StackBinopFunctionKind::Intrinsic(intrinsic_function)
                        }
@ -704,7 +717,7 @@ impl mir::Expression {
                let lhs = lhs_val.instr();
                let rhs = rhs_val.instr();

-                let operation = scope.binops.get(&ScopeBinopKey {
+                let operation = scope.binops.get(&BinopKey {
                    params: (lhs_val.1.clone(), rhs_val.1.clone()),
                    operator: *binop,
                });
--- a/reid/src/codegen/scope.rs
+++ b/reid/src/codegen/scope.rs
@ -8,7 +8,7 @@ use reid_lib::{

 use crate::{
    lexer::FullToken,
-    mir::{pass::ScopeBinopKey, CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind},
+    mir::{pass::BinopKey, CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind},
 };

 use super::{allocator::Allocator, ErrorKind, IntrinsicFunction, ModuleCodegen};
@ -24,7 +24,7 @@ pub struct Scope<'ctx, 'scope> {
    pub(super) types: &'scope HashMap<TypeValue, TypeDefinition>,
    pub(super) type_values: &'scope HashMap<CustomTypeKey, TypeValue>,
    pub(super) functions: &'scope HashMap<String, Function<'ctx>>,
-    pub(super) binops: &'scope HashMap<ScopeBinopKey, StackBinopDefinition<'ctx>>,
+    pub(super) binops: &'scope HashMap<BinopKey, StackBinopDefinition<'ctx>>,
    pub(super) stack_values: HashMap<String, StackValue>,
    pub(super) debug: Option<Debug<'ctx>>,
    pub(super) allocator: Rc<RefCell<Allocator>>,
@ -150,15 +150,9 @@ impl<'ctx> StackBinopDefinition<'ctx> {
            StackBinopFunctionKind::UserGenerated(ir) => {
                let instr = scope
                    .block
-                    .build(Instr::FunctionCall(
-                        ir.value(),
-                        vec![lhs.instr(), rhs.instr()],
-                    ))
+                    .build(Instr::FunctionCall(ir.value(), vec![lhs.instr(), rhs.instr()]))
                    .unwrap();
-                Ok(StackValue(
-                    StackValueKind::Immutable(instr),
-                    self.return_ty.clone(),
-                ))
+                Ok(StackValue(StackValueKind::Immutable(instr), self.return_ty.clone()))
            }
            StackBinopFunctionKind::Intrinsic(fun) => fun.codegen(scope, &[&lhs, &rhs]),
        }
--- a/reid/src/lib.rs
+++ b/reid/src/lib.rs
@ -130,7 +130,7 @@ pub fn perform_all_passes<'map>(
        for intrinsic in form_intrinsic_binops() {
            binops
                .set(
-                    mir::pass::ScopeBinopKey {
+                    mir::pass::BinopKey {
                        params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
                        operator: intrinsic.op,
                    },
@ -173,9 +173,9 @@ pub fn perform_all_passes<'map>(
        ));
    }

-    let refs = TypeRefs::with_binops(binops);
+    let mut refs = TypeRefs::with_binops(binops);

-    let state = context.pass(&mut TypeInference { refs: &refs })?;
+    let state = context.pass(&mut TypeInference { refs: &mut refs })?;

    #[cfg(debug_assertions)]
    println!("{:-^100}", "TYPE INFERRER OUTPUT");
--- a/reid/src/mir/fmt.rs
+++ b/reid/src/mir/fmt.rs
@ -66,8 +66,14 @@ impl Display for BinopDefinition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
-            "impl binop ({}: {:#}) {} ({}: {:#}) -> {:#} ",
-            self.lhs.0, self.lhs.1, self.op, self.rhs.0, self.rhs.1, self.return_type
+            "{}impl binop ({}: {:#}) {} ({}: {:#}) -> {:#} ",
+            if self.exported { "exported " } else { "" },
+            self.lhs.0,
+            self.lhs.1,
+            self.op,
+            self.rhs.0,
+            self.rhs.1,
+            self.return_type
        )?;
        Display::fmt(&self.fn_kind, f)
    }
@ -75,7 +81,17 @@ impl Display for BinopDefinition {

 impl Display for TypeDefinition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "type {} = ", self.name)?;
+        write!(
+            f,
+            "type {} (mod {}{}) = ",
+            self.name,
+            self.source_module,
+            if let Some(mod_id) = self.importer {
+                format!("; imported to {}", mod_id)
+            } else {
+                String::new()
+            }
+        )?;
        Display::fmt(&self.kind, f)
    }
 }
--- a/reid/src/mir/linker.rs
+++ b/reid/src/mir/linker.rs
@ -8,9 +8,13 @@ use std::{
 };

 use crate::{
+    codegen::scope,
    compile_module,
    error_raporting::{ErrorModules, ReidError},
-    mir::{CustomTypeKey, SourceModuleId, TypeDefinition, TypeKind},
+    mir::{
+        pass::BinopKey, BinopDefinition, CustomTypeKey, FunctionDefinitionKind, SourceModuleId, TypeDefinition,
+        TypeKind,
+    },
    parse_module,
 };

@ -31,8 +35,8 @@ pub enum ErrorKind {
    ModuleNotFound(String),
    #[error("Error while compiling module {0}: {1}")]
    ModuleCompilationError(String, String),
-    #[error("No such function {0} found in module {1}")]
-    NoSuchFunctionInModule(String, String),
+    #[error("No such value {0} found in module {1}")]
+    ImportDoesNotExist(String, String),
    #[error("Importing function {0}::{1} not possible: {2}")]
    FunctionImportIssue(String, String, EqualsIssue),
    #[error("Tried linking another main module: {0}")]
@ -65,10 +69,15 @@ pub struct LinkerPass<'map> {
    pub is_lib: bool,
 }

-type LinkerPassState<'st, 'sc> = PassState<'st, 'sc, (), ErrorKind>;
+#[derive(Default, Clone)]
+pub struct LinkerState {
+    extern_imported_types: HashMap<SourceModuleId, HashMap<String, SourceModuleId>>,
+}
+
+type LinkerPassState<'st, 'sc> = PassState<'st, 'sc, LinkerState, ErrorKind>;

 impl<'map> Pass for LinkerPass<'map> {
-    type Data = ();
+    type Data = LinkerState;
    type TError = ErrorKind;
    fn context(&mut self, context: &mut Context, mut state: LinkerPassState) -> PassResult {
        let mains = context
@ -104,17 +113,16 @@ impl<'map> Pass for LinkerPass<'map> {
        let mut modules_to_process: Vec<Rc<RefCell<_>>> = modules.values().cloned().collect();

        let mut already_imported_types = HashSet::<CustomTypeKey>::new();
+        let mut already_imported_binops = HashSet::<BinopKey>::new();

        while let Some(module) = modules_to_process.pop() {
+            let mut extern_types = HashMap::new();
            let mut importer_module = module.borrow_mut();

            for import in importer_module.imports.clone() {
                let Import(path, _) = &import;
                if path.len() != 2 {
-                    state.ok::<_, Infallible>(
-                        Err(ErrorKind::InnerModulesNotYetSupported(import.clone())),
-                        import.1,
-                    );
+                    state.ok::<_, Infallible>(Err(ErrorKind::InnerModulesNotYetSupported(import.clone())), import.1);
                }

                let module_name = unsafe { path.get_unchecked(0) };
@ -123,38 +131,30 @@ impl<'map> Pass for LinkerPass<'map> {
                    modules.get(mod_id).unwrap()
                } else if module_name == STD_NAME {
                    let std = compile_std(&mut self.module_map)?;
-                    modules.insert(
-                        std.module_id,
-                        Rc::new(RefCell::new(compile_std(&mut self.module_map)?)),
-                    );
+                    modules.insert(std.module_id, Rc::new(RefCell::new(compile_std(&mut self.module_map)?)));
                    module_ids.insert(std.name, std.module_id);
                    modules.get(&std.module_id).unwrap()
                } else {
-                    let file_path =
-                        PathBuf::from(&context.base.clone()).join(module_name.to_owned() + ".reid");
+                    let file_path = PathBuf::from(&context.base.clone()).join(module_name.to_owned() + ".reid");

                    let Ok(source) = fs::read_to_string(&file_path) else {
-                        state.ok::<_, Infallible>(
-                            Err(ErrorKind::ModuleNotFound(module_name.clone())),
-                            import.1,
-                        );
+                        state.ok::<_, Infallible>(Err(ErrorKind::ModuleNotFound(module_name.clone())), import.1);
                        continue;
                    };

-                    let (id, tokens) =
-                        match parse_module(&source, module_name.clone(), &mut self.module_map) {
-                            Ok(val) => val,
-                            Err(err) => {
-                                state.ok::<_, Infallible>(
-                                    Err(ErrorKind::ModuleCompilationError(
-                                        module_name.clone(),
-                                        format!("{}", err),
-                                    )),
-                                    import.1,
-                                );
-                                continue;
-                            }
-                        };
+                    let (id, tokens) = match parse_module(&source, module_name.clone(), &mut self.module_map) {
+                        Ok(val) => val,
+                        Err(err) => {
+                            state.ok::<_, Infallible>(
+                                Err(ErrorKind::ModuleCompilationError(
+                                    module_name.clone(),
+                                    format!("{}", err),
+                                )),
+                                import.1,
+                            );
+                            continue;
+                        }
+                    };

                    match compile_module(id, tokens, &mut self.module_map, Some(file_path), false) {
                        Ok(imported_module) => {
@ -166,8 +166,7 @@ impl<'map> Pass for LinkerPass<'map> {
                                continue;
                            }
                            let module_id = imported_module.module_id;
-                            module_ids
-                                .insert(imported_module.name.clone(), imported_module.module_id);
+                            module_ids.insert(imported_module.name.clone(), imported_module.module_id);
                            modules.insert(module_id, Rc::new(RefCell::new(imported_module)));
                            let imported = modules.get_mut(&module_id).unwrap();
                            modules_to_process.push(imported.clone());
@ -187,112 +186,104 @@ impl<'map> Pass for LinkerPass<'map> {
                }
                .borrow_mut();

-                let func_name = unsafe { path.get_unchecked(1) };
-
-                let Some(func) = imported.functions.iter_mut().find(|f| f.name == *func_name)
-                else {
-                    state.ok::<_, Infallible>(
-                        Err(ErrorKind::NoSuchFunctionInModule(
-                            module_name.clone(),
-                            func_name.clone(),
-                        )),
-                        import.1,
-                    );
-                    continue;
-                };
-
-                let func_name = func.name.clone();
-
-                if !func.is_pub {
-                    state.ok::<_, Infallible>(
-                        Err(ErrorKind::FunctionIsPrivate(
-                            module_name.clone(),
-                            func_name.clone(),
-                        )),
-                        import.1,
-                    );
-                    continue;
-                }
-
-                func.is_imported = true;
-
-                if let Some(existing) = importer_module
-                    .functions
-                    .iter()
-                    .find(|f| f.name == *func_name)
-                {
-                    if let Err(e) = existing.equals_as_imported(func) {
-                        state.ok::<_, Infallible>(
-                            Err(ErrorKind::FunctionImportIssue(
-                                module_name.clone(),
-                                func_name.clone(),
-                                e,
-                            )),
-                            import.1,
-                        );
-                    }
-                }
-
-                fn import_type(ty: &TypeKind) -> Vec<CustomTypeKey> {
-                    let mut imported_types = Vec::new();
-                    match &ty {
-                        TypeKind::CustomType(key) => imported_types.push(key.clone()),
-                        TypeKind::Borrow(ty, _) => imported_types.extend(import_type(ty)),
-                        TypeKind::Array(ty, _) => imported_types.extend(import_type(ty)),
-                        TypeKind::UserPtr(ty) => imported_types.extend(import_type(ty)),
-                        TypeKind::CodegenPtr(ty) => imported_types.extend(import_type(ty)),
-                        _ => {}
-                    };
-                    imported_types
-                }
+                let import_name = unsafe { path.get_unchecked(1) };

                let mut imported_types = Vec::new();

-                let types = import_type(&func.return_type);
-                let return_type = func.return_type.clone();
-                imported_types.extend(types);
+                if let Some(func) = imported.functions.iter_mut().find(|f| f.name == *import_name) {
+                    let func_name = func.name.clone();

-                let mut param_tys = Vec::new();
-                for (param_name, param_ty) in &func.parameters {
-                    let types = import_type(&param_ty);
-                    imported_types.extend(types);
-                    param_tys.push((param_name.clone(), param_ty.clone()));
-                }
+                    if !func.is_pub {
+                        state.ok::<_, Infallible>(
+                            Err(ErrorKind::FunctionIsPrivate(module_name.clone(), func_name.clone())),
+                            import.1,
+                        );
+                        continue;
+                    }

-                fn find_inner_types(
-                    typedef: &TypeDefinition,
-                    mut seen: HashSet<CustomTypeKey>,
-                    mod_id: SourceModuleId,
-                ) -> Vec<CustomTypeKey> {
-                    match &typedef.kind {
-                        crate::mir::TypeDefinitionKind::Struct(struct_type) => {
-                            let typenames = struct_type
-                                .0
-                                .iter()
-                                .filter(|t| matches!(t.1, TypeKind::CustomType(..)))
-                                .map(|t| match &t.1 {
-                                    TypeKind::CustomType(CustomTypeKey(t, _)) => t,
-                                    _ => panic!(),
-                                })
-                                .cloned()
-                                .collect::<Vec<_>>();
+                    func.is_imported = true;

-                            for typename in typenames {
-                                if seen.contains(&CustomTypeKey(typename.clone(), mod_id)) {
-                                    continue;
-                                }
-                                let inner = find_inner_types(typedef, seen.clone(), mod_id);
-                                seen.insert(CustomTypeKey(typename, mod_id));
-                                seen.extend(inner);
-                            }
-
-                            seen.into_iter().collect()
+                    if let Some(existing) = importer_module.functions.iter().find(|f| f.name == *func_name) {
+                        if let Err(e) = existing.equals_as_imported(func) {
+                            state.ok::<_, Infallible>(
+                                Err(ErrorKind::FunctionImportIssue(
+                                    module_name.clone(),
+                                    func_name.clone(),
+                                    e,
+                                )),
+                                import.1,
+                            );
                        }
                    }
+
+                    let types = import_type(&func.return_type, false);
+                    let return_type = func.return_type.clone();
+                    imported_types.extend(types);
+
+                    let mut param_tys = Vec::new();
+                    for (param_name, param_ty) in &func.parameters {
+                        let types = import_type(&param_ty, false);
+                        imported_types.extend(types);
+                        param_tys.push((param_name.clone(), param_ty.clone()));
+                    }
+
+                    importer_module.functions.push(FunctionDefinition {
+                        name: func_name,
+                        is_pub: false,
+                        is_imported: false,
+                        return_type,
+                        parameters: param_tys,
+                        kind: super::FunctionDefinitionKind::Extern(true),
+                    });
+                } else if let Some(ty) = imported.typedefs.iter_mut().find(|f| f.name == *import_name) {
+                    let external_key = CustomTypeKey(ty.name.clone(), ty.source_module);
+                    let imported_ty = TypeKind::CustomType(external_key.clone());
+                    imported_types.push((external_key, true));
+
+                    for binop in &mut imported.binop_defs {
+                        if binop.lhs.1 != imported_ty && binop.rhs.1 != imported_ty {
+                            continue;
+                        }
+                        let binop_key = BinopKey {
+                            params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                            operator: binop.op,
+                        };
+                        if already_imported_binops.contains(&binop_key) {
+                            continue;
+                        }
+                        binop.exported = true;
+                        already_imported_binops.insert(binop_key);
+                        match &binop.fn_kind {
+                            FunctionDefinitionKind::Local(block, metadata) => {
+                                importer_module.binop_defs.push(BinopDefinition {
+                                    lhs: binop.lhs.clone(),
+                                    op: binop.op,
+                                    rhs: binop.rhs.clone(),
+                                    return_type: binop.return_type.clone(),
+                                    fn_kind: FunctionDefinitionKind::Extern(true),
+                                    meta: binop.meta.clone(),
+                                    exported: false,
+                                });
+                            }
+                            FunctionDefinitionKind::Extern(_) => {}
+                            FunctionDefinitionKind::Intrinsic(_) => {}
+                        }
+                    }
+                } else {
+                    state.ok::<_, Infallible>(
+                        Err(ErrorKind::ImportDoesNotExist(module_name.clone(), import_name.clone())),
+                        import.1,
+                    );
+                    continue;
                }

                let mut seen = HashSet::new();
-                seen.extend(imported_types.clone());
+                let mut current_extern_types = HashSet::new();
+                seen.extend(imported_types.clone().iter().map(|t| t.0.clone()));
+                current_extern_types.extend(imported_types.clone().iter().filter(|t| t.1).map(|t| t.0.clone()));
+                for extern_type in &current_extern_types {
+                    extern_types.insert(extern_type.0.clone(), extern_type.1);
+                }

                let imported_mod_id = imported.module_id;
                let imported_mod_typedefs = &mut imported.typedefs;
@ -300,10 +291,10 @@ impl<'map> Pass for LinkerPass<'map> {
                for typekey in imported_types.clone() {
                    let typedef = imported_mod_typedefs
                        .iter()
-                        .find(|ty| CustomTypeKey(ty.name.clone(), imported_mod_id) == typekey)
+                        .find(|ty| CustomTypeKey(ty.name.clone(), imported_mod_id) == typekey.0)
                        .unwrap();
                    let inner = find_inner_types(typedef, seen.clone(), imported_mod_id);
-                    seen.extend(inner);
+                    seen.extend(inner.iter().cloned());
                }

                // TODO: Unable to import same-named type from multiple places..
@ -314,25 +305,41 @@ impl<'map> Pass for LinkerPass<'map> {

                already_imported_types.extend(seen.clone());

+                for typekey in &already_imported_types {
+                    if current_extern_types.contains(typekey) {
+                        let module_id = importer_module.module_id;
+                        let typedef = importer_module
+                            .typedefs
+                            .iter_mut()
+                            .find(|t| t.name == typekey.0 && t.source_module == typekey.1);
+                        if let Some(typedef) = typedef {
+                            typedef.importer = Some(module_id);
+                        }
+                    }
+                }
+
                for typekey in seen.into_iter() {
-                    let typedef = imported_mod_typedefs
+                    let mut typedef = imported_mod_typedefs
                        .iter()
                        .find(|ty| CustomTypeKey(ty.name.clone(), imported_mod_id) == typekey)
                        .unwrap()
                        .clone();

-                    importer_module.typedefs.push(typedef.clone());
-                }
+                    if current_extern_types.contains(&typekey) {
+                        typedef = TypeDefinition {
+                            importer: Some(importer_module.module_id),
+                            ..typedef
+                        };
+                    }

-                importer_module.functions.push(FunctionDefinition {
-                    name: func_name,
-                    is_pub: false,
-                    is_imported: false,
-                    return_type,
-                    parameters: param_tys,
-                    kind: super::FunctionDefinitionKind::Extern(true),
-                });
+                    importer_module.typedefs.push(typedef);
+                }
            }
+            state
+                .scope
+                .data
+                .extern_imported_types
+                .insert(importer_module.module_id, extern_types);
        }

        let mut modules: Vec<Module> = modules
@ -346,4 +353,142 @@ impl<'map> Pass for LinkerPass<'map> {

        Ok(())
    }
+
+    fn function(
+        &mut self,
+        function: &mut FunctionDefinition,
+        state: PassState<Self::Data, Self::TError>,
+    ) -> PassResult {
+        if matches!(function.kind, FunctionDefinitionKind::Local(_, _)) {
+            let mod_id = state.scope.module_id.unwrap();
+            let extern_types = &state.scope.data.extern_imported_types.get(&mod_id);
+            if let Some(extern_types) = extern_types {
+                function.return_type = function.return_type.update_imported(*extern_types, mod_id);
+                for param in function.parameters.iter_mut() {
+                    param.1 = param.1.update_imported(extern_types, mod_id);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn stmt(&mut self, stmt: &mut super::Statement, state: PassState<Self::Data, Self::TError>) -> PassResult {
+        let mod_id = state.scope.module_id.unwrap();
+        let extern_types = &state.scope.data.extern_imported_types.get(&mod_id);
+        if let Some(extern_types) = extern_types {
+            match &mut stmt.0 {
+                super::StmtKind::Let(var_ref, _, _) => {
+                    var_ref.0 = var_ref.0.update_imported(extern_types, mod_id);
+                }
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+
+    fn expr(&mut self, expr: &mut super::Expression, state: PassState<Self::Data, Self::TError>) -> PassResult {
+        let mod_id = state.scope.module_id.unwrap();
+        let extern_types = &state.scope.data.extern_imported_types.get(&mod_id);
+        if let Some(extern_types) = extern_types {
+            match &mut expr.0 {
+                super::ExprKind::Variable(var_ref) => {
+                    var_ref.0 = var_ref.0.update_imported(extern_types, mod_id);
+                }
+                super::ExprKind::Indexed(.., type_kind, _) => {
+                    *type_kind = type_kind.update_imported(extern_types, mod_id)
+                }
+                super::ExprKind::Accessed(.., type_kind, _) => {
+                    *type_kind = type_kind.update_imported(extern_types, mod_id)
+                }
+                super::ExprKind::BinOp(.., type_kind) => *type_kind = type_kind.update_imported(extern_types, mod_id),
+
+                super::ExprKind::Borrow(var_ref, _) => {
+                    var_ref.0 = var_ref.0.update_imported(extern_types, mod_id);
+                }
+                super::ExprKind::Deref(var_ref) => {
+                    var_ref.0 = var_ref.0.update_imported(extern_types, mod_id);
+                }
+                super::ExprKind::CastTo(_, type_kind) => *type_kind = type_kind.update_imported(extern_types, mod_id),
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+}
+
+impl TypeKind {
+    fn update_imported(
+        &self,
+        extern_types: &HashMap<String, SourceModuleId>,
+        importer_mod_id: SourceModuleId,
+    ) -> TypeKind {
+        match &self {
+            TypeKind::Array(type_kind, len) => {
+                TypeKind::Array(Box::new(type_kind.update_imported(extern_types, importer_mod_id)), *len)
+            }
+            TypeKind::CustomType(custom_type_key) => {
+                if let Some(mod_id) = extern_types.get(&custom_type_key.0) {
+                    TypeKind::CustomType(CustomTypeKey(custom_type_key.0.clone(), *mod_id))
+                } else {
+                    self.clone()
+                }
+            }
+            TypeKind::Borrow(type_kind, mutable) => TypeKind::Borrow(
+                Box::new(type_kind.update_imported(extern_types, importer_mod_id)),
+                *mutable,
+            ),
+            TypeKind::UserPtr(type_kind) => {
+                TypeKind::UserPtr(Box::new(type_kind.update_imported(extern_types, importer_mod_id)))
+            }
+            TypeKind::CodegenPtr(type_kind) => {
+                TypeKind::CodegenPtr(Box::new(type_kind.update_imported(extern_types, importer_mod_id)))
+            }
+            _ => self.clone(),
+        }
+    }
+}
+
+fn import_type(ty: &TypeKind, usable_import: bool) -> Vec<(CustomTypeKey, bool)> {
+    let mut imported_types = Vec::new();
+    match &ty {
+        TypeKind::CustomType(key) => imported_types.push((key.clone(), usable_import)),
+        TypeKind::Borrow(ty, _) => imported_types.extend(import_type(ty, usable_import)),
+        TypeKind::Array(ty, _) => imported_types.extend(import_type(ty, usable_import)),
+        TypeKind::UserPtr(ty) => imported_types.extend(import_type(ty, usable_import)),
+        TypeKind::CodegenPtr(ty) => imported_types.extend(import_type(ty, usable_import)),
+        _ => {}
+    };
+    imported_types
+}
+
+fn find_inner_types(
+    typedef: &TypeDefinition,
+    mut seen: HashSet<CustomTypeKey>,
+    mod_id: SourceModuleId,
+) -> Vec<CustomTypeKey> {
+    match &typedef.kind {
+        crate::mir::TypeDefinitionKind::Struct(struct_type) => {
+            let typenames = struct_type
+                .0
+                .iter()
+                .filter(|t| matches!(t.1, TypeKind::CustomType(..)))
+                .map(|t| match &t.1 {
+                    TypeKind::CustomType(CustomTypeKey(t, _)) => t,
+                    _ => panic!(),
+                })
+                .cloned()
+                .collect::<Vec<_>>();
+
+            for typename in typenames {
+                if seen.contains(&CustomTypeKey(typename.clone(), mod_id)) {
+                    continue;
+                }
+                let inner = find_inner_types(typedef, seen.clone(), mod_id);
+                seen.insert(CustomTypeKey(typename, mod_id));
+                seen.extend(inner);
+            }
+
+            seen.into_iter().collect()
+        }
+    }
 }
--- a/reid/src/mir/mod.rs
+++ b/reid/src/mir/mod.rs
@ -354,6 +354,7 @@ pub struct TypeDefinition {
    pub kind: TypeDefinitionKind,
    pub meta: Metadata,
    pub source_module: SourceModuleId,
+    pub importer: Option<SourceModuleId>,
 }

 #[derive(Debug, Clone)]
@ -369,6 +370,8 @@ pub struct BinopDefinition {
    pub return_type: TypeKind,
    pub fn_kind: FunctionDefinitionKind,
    pub meta: Metadata,
+    // Wether this binop definition has been imported into another module.
+    pub exported: bool,
 }

 impl BinopDefinition {
--- a/reid/src/mir/pass.rs
+++ b/reid/src/mir/pass.rs
@ -117,10 +117,11 @@ impl<Key: std::hash::Hash + Eq, T: Clone + std::fmt::Debug> Storage<Key, T> {
    }
 }

-pub type BinopMap = Storage<ScopeBinopKey, ScopeBinopDef>;
+pub type BinopMap = Storage<BinopKey, ScopeBinopDef>;

 #[derive(Clone, Default, Debug)]
 pub struct Scope<Data: Clone + Default> {
+    pub module_id: Option<SourceModuleId>,
    pub binops: BinopMap,
    pub function_returns: Storage<String, ScopeFunction>,
    pub variables: Storage<String, ScopeVariable>,
@ -133,6 +134,7 @@ pub struct Scope<Data: Clone + Default> {
 impl<Data: Clone + Default> Scope<Data> {
    pub fn inner(&self) -> Scope<Data> {
        Scope {
+            module_id: self.module_id,
            function_returns: self.function_returns.clone(),
            variables: self.variables.clone(),
            binops: self.binops.clone(),
@ -156,6 +158,15 @@ impl<Data: Clone + Default> Scope<Data> {
            .find(|(CustomTypeKey(n, _), _)| n == name)
            .map(|(key, _)| key)
    }
+
+    pub fn get_type(&self, typekey: &CustomTypeKey) -> Option<&TypeDefinition> {
+        self.types.get(&typekey).or(self
+            .types
+            .0
+            .iter()
+            .find(|(key, def)| key.0 == typekey.0 && def.importer == Some(typekey.1))
+            .map(|(_, v)| v))
+    }
 }

 #[derive(Clone, Debug)]
@ -171,7 +182,7 @@ pub struct ScopeVariable {
 }

 #[derive(Clone, Debug, Eq)]
-pub struct ScopeBinopKey {
+pub struct BinopKey {
    pub params: (TypeKind, TypeKind),
    pub operator: BinaryOperator,
 }
@ -183,7 +194,7 @@ pub enum CommutativeKind {
    Any,
 }

-impl PartialEq for ScopeBinopKey {
+impl PartialEq for BinopKey {
    fn eq(&self, other: &Self) -> bool {
        if self.operator != other.operator {
            return false;
@ -205,7 +216,7 @@ impl PartialEq for ScopeBinopKey {
    }
 }

-impl std::hash::Hash for ScopeBinopKey {
+impl std::hash::Hash for BinopKey {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        if self.operator.is_commutative() {
            let mut sorted = vec![&self.params.0, &self.params.1];
@ -325,7 +336,7 @@ impl Context {
            scope
                .binops
                .set(
-                    ScopeBinopKey {
+                    BinopKey {
                        params: (intrinsic.lhs.1.clone(), intrinsic.rhs.1.clone()),
                        operator: intrinsic.op,
                    },
@ -347,6 +358,8 @@ impl Context {

 impl Module {
    fn pass<T: Pass>(&mut self, pass: &mut T, state: &mut State<T::TError>, scope: &mut Scope<T::Data>) -> PassResult {
+        scope.module_id = Some(self.module_id);
+
        for typedef in &self.typedefs {
            scope
                .types
@ -361,7 +374,7 @@ impl Module {
            scope
                .binops
                .set(
-                    ScopeBinopKey {
+                    BinopKey {
                        params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
                        operator: binop.op,
                    },
--- a/reid/src/mir/typecheck/mod.rs
+++ b/reid/src/mir/typecheck/mod.rs
@ -300,8 +300,7 @@ impl TypeKind {
            TypeKind::CustomType(custom_type_key) => {
                state
                    .scope
-                    .types
-                    .get(custom_type_key)
+                    .get_type(custom_type_key)
                    .map(|_| ())
                    .ok_or(ErrorKind::NoSuchType(
                        custom_type_key.0.clone(),
--- a/reid/src/mir/typecheck/typecheck.rs
+++ b/reid/src/mir/typecheck/typecheck.rs
@ -34,12 +34,7 @@ impl<'t> Pass for TypeCheck<'t> {
    fn module(&mut self, module: &mut Module, mut state: TypecheckPassState) -> PassResult {
        let mut defmap = HashMap::new();
        for typedef in &module.typedefs {
-            let TypeDefinition {
-                name,
-                kind,
-                meta,
-                source_module: _,
-            } = &typedef;
+            let TypeDefinition { name, kind, meta, .. } = &typedef;

            match kind {
                TypeDefinitionKind::Struct(StructType(fields)) => {
@ -55,8 +50,10 @@ impl<'t> Pass for TypeCheck<'t> {
                }
            }

-            if let Some(_) = defmap.insert(&typedef.name, typedef) {
-                state.ok::<_, Infallible>(Err(ErrorKind::DuplicateTypeName(name.clone())), meta.clone());
+            if typedef.source_module == module.module_id || typedef.importer == Some(module.module_id) {
+                if let Some(_) = defmap.insert(&typedef.name, typedef) {
+                    state.ok::<_, Infallible>(Err(ErrorKind::DuplicateTypeName(name.clone())), meta.clone());
+                }
            }
        }

@ -217,8 +214,6 @@ impl Block {
                        variable_reference.2,
                    );

-                    dbg!(&var_t_resolved);
-
                    // Typecheck (and coerce) expression with said type
                    let res = expression.typecheck(&mut state, &typerefs, HintKind::Coerce(var_t_resolved.clone()));
                    // If expression resolution itself was erronous, resolve as
@ -427,7 +422,7 @@ impl Expression {
                    );
                };

-                let binops = state.scope.binops.filter(&pass::ScopeBinopKey {
+                let binops = state.scope.binops.filter(&pass::BinopKey {
                    params: (lhs_type.clone(), rhs_type.clone()),
                    operator: *op,
                });
--- a/reid/src/mir/typecheck/typeinference.rs
+++ b/reid/src/mir/typecheck/typeinference.rs
@ -20,7 +20,7 @@ use crate::{

 use super::{
    super::{
-        pass::{Pass, PassResult, PassState, ScopeBinopKey},
+        pass::{BinopKey, Pass, PassResult, PassState},
        TypeKind::*,
        VagueType::*,
    },
@ -33,7 +33,7 @@ use super::{
 /// TypeRefs-struct is used as a helper to go through the modules and change
 /// types while inferring.
 pub struct TypeInference<'t> {
-    pub refs: &'t TypeRefs,
+    pub refs: &'t mut TypeRefs,
 }

 impl<'t> Pass for TypeInference<'t> {
@ -62,7 +62,7 @@ impl<'t> Pass for TypeInference<'t> {

        let mut seen_binops = HashSet::new();
        for binop in &module.binop_defs {
-            let binop_key = ScopeBinopKey {
+            let binop_key = BinopKey {
                params: (binop.lhs.1.clone(), binop.rhs.1.clone()),
                operator: binop.op,
            };
@ -77,7 +77,18 @@ impl<'t> Pass for TypeInference<'t> {
                    binop.signature(),
                );
            } else {
-                seen_binops.insert(binop_key);
+                seen_binops.insert(binop_key.clone());
+                self.refs
+                    .binop_types
+                    .set(
+                        binop_key,
+                        crate::mir::pass::ScopeBinopDef {
+                            hands: (binop.lhs.1.clone(), binop.rhs.1.clone()),
+                            operator: binop.op,
+                            return_ty: binop.return_type.clone(),
+                        },
+                    )
+                    .ok();
            }
        }

@ -119,7 +130,6 @@ impl BinopDefinition {
            .fn_kind
            .infer_types(state, &scope_hints, Some(self.return_type.clone()))?;
        if let Some(mut ret_ty) = ret_ty {
-            dbg!(&ret_ty, &self.return_type);
            ret_ty.narrow(&scope_hints.from_type(&self.return_type).unwrap());
        }

@ -320,7 +330,7 @@ impl Expression {
                            continue;
                        }
                        if binop.operator.is_commutative() {
-                            if let Some(_) = binop.narrow(&lhs_ty, &rhs_ty) {
+                            if let Some(_) = binop.narrow(&rhs_ty, &lhs_ty) {
                                applying_binops.push(binop.clone());
                                continue;
                            }
@ -330,7 +340,6 @@ impl Expression {
                } else {
                    Vec::new()
                };
-
                if binops.len() > 0 {
                    let binop = unsafe { binops.get_unchecked(0) };
                    let mut widened_lhs = binop.hands.0.clone();
--- a/reid/src/mir/typecheck/typerefs.rs
+++ b/reid/src/mir/typecheck/typerefs.rs
@ -10,7 +10,7 @@ use crate::{
 };

 use super::{
-    super::pass::{ScopeBinopDef, ScopeBinopKey, Storage},
+    super::pass::{BinopKey, ScopeBinopDef, Storage},
    ErrorKind,
 };

@ -80,7 +80,7 @@ impl TypeRefKind {
                    while let Some(other) = binops.next() {
                        ty = ty.widen_into(&other);
                    }
-                    ty
+                    ty.clone()
                } else {
                    TypeKind::Vague(VagueType::Unknown)
                }
--- a/reid/tests/e2e.rs
+++ b/reid/tests/e2e.rs
@ -34,9 +34,7 @@ fn test(source: &str, name: &str, expected_exit_code: Option<i32>) {
        let time = SystemTime::now();
        let in_path = PathBuf::from(format!(
            "/tmp/temp-{}.o",
-            time.duration_since(SystemTime::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
+            time.duration_since(SystemTime::UNIX_EPOCH).unwrap().as_nanos()
        ));

        std::fs::write(&in_path, &output.obj_buffer).expect("Could not write OBJ-file!");
@ -60,19 +58,11 @@ fn test(source: &str, name: &str, expected_exit_code: Option<i32>) {

 #[test]
 fn arithmetic_compiles_well() {
-    test(
-        include_str!("../../examples/arithmetic.reid"),
-        "test",
-        Some(48),
-    );
+    test(include_str!("../../examples/arithmetic.reid"), "test", Some(48));
 }
 #[test]
 fn array_structs_compiles_well() {
-    test(
-        include_str!("../../examples/array_structs.reid"),
-        "test",
-        Some(5),
-    );
+    test(include_str!("../../examples/array_structs.reid"), "test", Some(5));
 }
 #[test]
 fn array_compiles_well() {
@ -84,11 +74,7 @@ fn borrow_compiles_well() {
 }
 #[test]
 fn borrow_hard_compiles_well() {
-    test(
-        include_str!("../../examples/borrow_hard.reid"),
-        "test",
-        Some(17),
-    );
+    test(include_str!("../../examples/borrow_hard.reid"), "test", Some(17));
 }
 #[test]
 fn cast_compiles_well() {
@ -100,19 +86,11 @@ fn char_compiles_well() {
 }
 #[test]
 fn div_mod_compiles_well() {
-    test(
-        include_str!("../../examples/div_mod.reid"),
-        "test",
-        Some(12),
-    );
+    test(include_str!("../../examples/div_mod.reid"), "test", Some(12));
 }
 #[test]
 fn fibonacci_compiles_well() {
-    test(
-        include_str!("../../examples/fibonacci.reid"),
-        "test",
-        Some(1),
-    );
+    test(include_str!("../../examples/fibonacci.reid"), "test", Some(1));
 }
 #[test]
 fn float_compiles_well() {
@ -120,19 +98,11 @@ fn float_compiles_well() {
 }
 #[test]
 fn hello_world_compiles_well() {
-    test(
-        include_str!("../../examples/hello_world.reid"),
-        "test",
-        None,
-    );
+    test(include_str!("../../examples/hello_world.reid"), "test", None);
 }
 #[test]
 fn mutable_compiles_well() {
-    test(
-        include_str!("../../examples/mutable.reid"),
-        "test",
-        Some(21),
-    );
+    test(include_str!("../../examples/mutable.reid"), "test", Some(21));
 }
 #[test]
 fn ptr_compiles_well() {
@ -140,11 +110,7 @@ fn ptr_compiles_well() {
 }
 #[test]
 fn std_test_compiles_well() {
-    test(
-        include_str!("../../examples/std_test.reid"),
-        "test",
-        Some(3),
-    );
+    test(include_str!("../../examples/std_test.reid"), "test", Some(3));
 }
 #[test]
 fn strings_compiles_well() {
@ -160,34 +126,22 @@ fn loops_compiles_well() {
 }
 #[test]
 fn ptr_hard_compiles_well() {
-    test(
-        include_str!("../../examples/ptr_hard.reid"),
-        "test",
-        Some(0),
-    );
+    test(include_str!("../../examples/ptr_hard.reid"), "test", Some(0));
 }
 #[test]
 fn loop_hard_compiles_well() {
-    test(
-        include_str!("../../examples/loop_hard.reid"),
-        "test",
-        Some(0),
-    );
+    test(include_str!("../../examples/loop_hard.reid"), "test", Some(0));
 }
 #[test]
 fn custom_binop_compiles_well() {
-    test(
-        include_str!("../../examples/custom_binop.reid"),
-        "test",
-        Some(21),
-    );
+    test(include_str!("../../examples/custom_binop.reid"), "test", Some(21));
 }

 #[test]
 fn array_short_compiles_well() {
-    test(
-        include_str!("../../examples/array_short.reid"),
-        "test",
-        Some(5),
-    );
+    test(include_str!("../../examples/array_short.reid"), "test", Some(5));
+}
+#[test]
+fn imported_type_compiles_well() {
+    test(include_str!("../../examples/imported_type.reid"), "test", Some(0));
 }
Author	SHA1	Message	Date
sofia	5991a75d32	Add imported_type to e2e-tests	2025-07-26 14:05:06 +03:00
sofia	0ba1fa90e7	Update readme, clean up a little	2025-07-26 14:04:24 +03:00
sofia	c316d94b75	Fix bug in custom binops where their return types aren't inferred	2025-07-26 14:01:53 +03:00
sofia	0196fb53ed	Import binops while importing types as well	2025-07-26 13:18:55 +03:00
sofia	58cc633f98	Update typerefs in statements and expressions as well for extern types	2025-07-26 12:56:42 +03:00
sofia	59e4c38770	Fix type references for function return types .. for now	2025-07-26 01:34:37 +03:00
sofia	19120492b9	Update get_type to accept imported types as well	2025-07-26 01:02:25 +03:00
sofia	269de327b8	Allow importing types	2025-07-26 00:57:39 +03:00