reid-llvm-lib/src/builder.rs

@@ -14,10 +14,10 @@ use crate::{
     util::match_types,
 };
 
-#[derive(Clone, Hash, Copy, PartialEq, Eq, PartialOrd)]
+#[derive(Clone, Hash, Copy, PartialEq, Eq)]
 pub struct ModuleValue(pub(crate) usize);
 
-#[derive(Clone, Hash, Copy, PartialEq, Eq, PartialOrd)]
+#[derive(Clone, Hash, Copy, PartialEq, Eq)]
 pub struct TypeValue(pub(crate) ModuleValue, pub(crate) usize);
 
 #[derive(Clone, Hash, Copy, PartialEq, Eq)]
@@ -517,7 +517,7 @@ impl Builder {
                     }
                     for (a, b) in param_types.iter().zip(params) {
                         if *a != b.get_type(&self)? {
-                            return Err(ErrorKind::TypesIncompatible(a.clone(), b.get_type(&self)?)); // TODO error: params do not match
+                            return Err(ErrorKind::Null); // TODO error: params do not match
                         }
                     }
                     Ok(())

reid-llvm-lib/src/lib.rs

@@ -26,8 +26,6 @@ mod util;
 pub enum ErrorKind {
     #[error("NULL error, should never occur!")]
     Null,
-    #[error("Types {0:?} and {1:?} incompatible")]
-    TypesIncompatible(Type, Type),
 }
 
 pub type CompileResult<T> = Result<T, ErrorKind>;
@@ -500,7 +498,7 @@ pub enum Instr {
     FunctionCall(FunctionValue, Vec<InstructionValue>),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Hash, PartialOrd)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum Type {
     I8,
     I16,

reid/src/mir/fmt.rs

@@ -117,7 +117,7 @@ impl Display for TypeDefinition {
             self.name,
             self.source_module,
             if let Some(mod_id) = self.importer {
-                format!("; imported by {}", mod_id)
+                format!("; imported to {}", mod_id)
             } else {
                 String::new()
             }

reid/src/mir/linker.rs

@@ -336,16 +336,10 @@ impl<'map> Pass for LinkerPass<'map> {
                     }
 
                     for ty in import_type(&func.return_type) {
-                        if unresolved_types.contains_key(&ty) {
-                            continue;
-                        }
                         unresolved_types.insert(ty, (meta.clone(), true));
                     }
                     for param in &func.parameters {
                         for ty in import_type(&param.ty) {
-                            if unresolved_types.contains_key(&ty) {
-                                continue;
-                            }
                             unresolved_types.insert(ty, (meta.clone(), true));
                         }
                     }
@@ -354,6 +348,8 @@ impl<'map> Pass for LinkerPass<'map> {
                 unresolved_types.insert(imported_ty_key.clone(), (meta.clone(), false));
             }
 
+            dbg!(&importer_module.module_id, &unresolved_types);
+
             // 3. Recurse these types to find their true sources, find their
             //    dependencies, and list them all. Store manually imported types
             //    in a separate mapping for later.
@@ -378,7 +374,19 @@ impl<'map> Pass for LinkerPass<'map> {
                         }
                     };
 
-                    imported_types.insert(CustomTypeKey(ty.0.clone(), importer_module.module_id), ty.1);
+                    match resolve_types_recursively(
+                        &TypeKind::CustomType(CustomTypeKey(ty.0.clone(), importer_module.module_id)),
+                        &modules,
+                        HashSet::new(),
+                    ) {
+                        Ok(resolved) => {
+                            imported_types.extend(resolved);
+                        }
+                        Err(e) => {
+                            state.note_errors(&vec![e], meta);
+                            return Ok(());
+                        }
+                    }
 
                     let mut imported = modules.get(&imported_ty_key.1).unwrap().module.borrow_mut();
                     let imported_module_name = imported.name.clone();
@@ -470,6 +478,7 @@ impl<'map> Pass for LinkerPass<'map> {
                         ));
                     }
                 }
+
                 match resolve_types_recursively(&TypeKind::CustomType(ty.clone()), &modules, HashSet::new()) {
                     Ok(resolved) => {
                         imported_types.extend(resolved);
@@ -481,29 +490,20 @@ impl<'map> Pass for LinkerPass<'map> {
                 }
             }
 
-            let mut typedef_keys = HashMap::new();
+            dbg!(&imported_types);
+
             // 4. Import all listed types.
             for (importer_typekey, imported_module_id) in &imported_types {
+                let imported_ty_module = modules.get(&imported_module_id).unwrap().module.borrow();
                 let importee_typekey = CustomTypeKey(importer_typekey.0.clone(), *imported_module_id);
-                if let Some(module_id) = typedef_keys.get(&importee_typekey) {
-                    if *module_id != importer_module.module_id {
-                        typedef_keys.insert(importee_typekey.clone(), importer_typekey.1);
-                    }
-                } else {
-                    typedef_keys.insert(importee_typekey.clone(), importer_typekey.1);
-                }
-            }
-
-            for (typedef_key, importer_module_id) in &typedef_keys {
-                let imported_ty_module = modules.get(&typedef_key.1).unwrap().module.borrow();
                 if let Some(typedef) = imported_ty_module
                     .typedefs
                     .iter()
-                    .find(|ty| CustomTypeKey(ty.name.clone(), ty.source_module) == *typedef_key)
+                    .find(|ty| CustomTypeKey(ty.name.clone(), ty.source_module) == importee_typekey)
                     .cloned()
                 {
                     importer_module.typedefs.push(TypeDefinition {
-                        importer: Some(*importer_module_id),
+                        importer: Some(importer_typekey.1),
                         ..typedef
                     });
                 }