teascade/reid-llvm
1
1
Fork 0
Code Issues Pull Requests Packages Releases 6 Wiki Activity

Resolve types recursively instead of just on-surface

Browse Source
This commit is contained in:
Sofia 2025-08-06 21:36:33 +03:00
parent 3dba4a79ff
commit a5c7823a29
2 changed files with 56 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
reid/src/codegen/mod.rs
View File

@ -182,16 +182,13 @@ impl mir::Module {
insert_debug!(&TypeKind::Void);
insert_debug!(&TypeKind::Char);
let mut typedefs = self.typedefs.clone();
typedefs.sort_by(|a, b| b.source_module.cmp(&a.source_module));
// Since we know by this point that no types are recursive, we can
// somewhat easily sort the type-definitions such that we can process
// the ones with no depencencies first, and later the ones that depend
// on the earlier ones.
let mut typekeys_seen = HashSet::new();
let mut typedefs_sorted = Vec::new();
let mut typedefs_left = typedefs.clone();
let mut typedefs_left = self.typedefs.clone();
typedefs_left.reverse();
while let Some(typedef) = typedefs_left.pop() {
match &typedef.kind {

65
reid/src/mir/linker.rs
View File

@ -373,10 +373,20 @@ impl<'map> Pass for LinkerPass<'map> {
return Ok(());
}
};
imported_types.insert(
CustomTypeKey(ty.0.clone(), importer_module.module_id),
imported_ty_key.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();
@ -469,15 +479,22 @@ impl<'map> Pass for LinkerPass<'map> {
}
}
let resolved = match resolve_type(&ty, &modules) {
Ok(ty) => ty.clone(),
match resolve_types_recursively(&TypeKind::CustomType(ty.clone()), &modules, HashSet::new()) {
Ok(resolved) => {
imported_types.extend(resolved);
}
Err(e) => {
state.note_errors(&vec![e], meta);
return Ok(());
}
};
imported_types.insert(ty, resolved.1);
}
// let resolved = match resolve_type(&ty, &modules) {
// Ok(ty) => ty.clone(),
// Err(e) => {
// state.note_errors(&vec![e], meta);
// return Ok(());
// }
// };
}
dbg!(&imported_types);
@ -656,19 +673,20 @@ fn resolve_type(
}
fn resolve_types_recursively(
ty: &CustomTypeKey,
resolver: SourceModuleId,
ty: &TypeKind,
modules: &HashMap<SourceModuleId, LinkerModule>,
mut seen: HashSet<CustomTypeKey>,
) -> Result<HashMap<CustomTypeKey, SourceModuleId>, ErrorKind> {
let resolved_ty = resolve_type(ty, modules)?;
let mut types = HashMap::new();
match ty {
TypeKind::CustomType(type_key) => {
let resolved_ty = resolve_type(type_key, modules)?;
if seen.contains(&resolved_ty) {
return Err(ErrorKind::CyclicalType(ty.0.clone()));
return Err(ErrorKind::CyclicalType(type_key.0.clone()));
}
let mut types = HashMap::new();
types.insert(CustomTypeKey(ty.0.clone(), resolver), resolved_ty.1);
types.insert(type_key.clone(), resolved_ty.1);
seen.insert(resolved_ty.clone());
let resolved = modules
@ -679,20 +697,21 @@ fn resolve_types_recursively(
.typedefs
.iter()
.find(|t| t.name == resolved_ty.0)
.ok_or(ErrorKind::NoSuchTypeInModule(ty.clone()))
.ok_or(ErrorKind::NoSuchTypeInModule(type_key.clone()))
.cloned()?;
match resolved.kind {
TypeDefinitionKind::Struct(StructType(fields)) => {
for field in fields {
match &field.1 {
TypeKind::CustomType(ty_key) => {
types.extend(resolve_types_recursively(ty_key, resolved_ty.1, modules, seen.clone())?);
types.extend(resolve_types_recursively(&field.1, modules, seen.clone())?);
}
}
}
}
TypeKind::Array(type_kind, _) => types.extend(resolve_types_recursively(&type_kind, modules, seen.clone())?),
TypeKind::Borrow(type_kind, _) => types.extend(resolve_types_recursively(&type_kind, modules, seen.clone())?),
TypeKind::UserPtr(type_kind) => types.extend(resolve_types_recursively(&type_kind, modules, seen.clone())?),
TypeKind::CodegenPtr(type_kind) => types.extend(resolve_types_recursively(&type_kind, modules, seen.clone())?),
_ => {}
}
}
}
}
Ok(types)
}