Fix inconsitent multiple typedefs

reid-llvm-lib/src/builder.rs

@@ -14,10 +14,10 @@ use crate::{
     util::match_types,
 };
 
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
+#[derive(Clone, Hash, Copy, PartialEq, Eq, PartialOrd)]
 pub struct ModuleValue(pub(crate) usize);
 
-#[derive(Clone, Hash, Copy, PartialEq, Eq)]
+#[derive(Clone, Hash, Copy, PartialEq, Eq, PartialOrd)]
 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::Null); // TODO error: params do not match
+                            return Err(ErrorKind::TypesIncompatible(a.clone(), b.get_type(&self)?)); // TODO error: params do not match
                         }
                     }
                     Ok(())

reid-llvm-lib/src/lib.rs

@@ -26,6 +26,8 @@ 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>;
@@ -498,7 +500,7 @@ pub enum Instr {
     FunctionCall(FunctionValue, Vec<InstructionValue>),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, PartialOrd)]
 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 to {}", mod_id)
+                format!("; imported by {}", mod_id)
             } else {
                 String::new()
             }

reid/src/mir/linker.rs

@@ -336,10 +336,16 @@ 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));
                         }
                     }
@@ -348,8 +354,6 @@ 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.
@@ -374,19 +378,7 @@ impl<'map> Pass for LinkerPass<'map> {
                         }
                     };
 
-                    match resolve_types_recursively(
+                    imported_types.insert(CustomTypeKey(ty.0.clone(), importer_module.module_id), ty.1);
-                        &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();
@@ -478,7 +470,6 @@ impl<'map> Pass for LinkerPass<'map> {
                         ));
                     }
                 }
-
                 match resolve_types_recursively(&TypeKind::CustomType(ty.clone()), &modules, HashSet::new()) {
                     Ok(resolved) => {
                         imported_types.extend(resolved);
@@ -490,20 +481,29 @@ impl<'map> Pass for LinkerPass<'map> {
                 }
             }
 
-            dbg!(&imported_types);
+            let mut typedef_keys = HashMap::new();
-
             // 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) == importee_typekey)
+                    .find(|ty| CustomTypeKey(ty.name.clone(), ty.source_module) == *typedef_key)
                     .cloned()
                 {
                     importer_module.typedefs.push(TypeDefinition {
-                        importer: Some(importer_typekey.1),
+                        importer: Some(*importer_module_id),
                         ..typedef
                     });
                 }