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::Void);
insert_debug!(&TypeKind::Char); 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 // Since we know by this point that no types are recursive, we can
// somewhat easily sort the type-definitions such that we can process // somewhat easily sort the type-definitions such that we can process
// the ones with no depencencies first, and later the ones that depend // the ones with no depencencies first, and later the ones that depend
// on the earlier ones. // on the earlier ones.
let mut typekeys_seen = HashSet::new(); let mut typekeys_seen = HashSet::new();
let mut typedefs_sorted = Vec::new(); let mut typedefs_sorted = Vec::new();
let mut typedefs_left = typedefs.clone(); let mut typedefs_left = self.typedefs.clone();
typedefs_left.reverse(); typedefs_left.reverse();
while let Some(typedef) = typedefs_left.pop() { while let Some(typedef) = typedefs_left.pop() {
match &typedef.kind { match &typedef.kind {

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

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