windows-clang dependency-resolution cleanup

crates/libs/clang/src/canon.rs

@@ -42,7 +42,7 @@ pub(crate) fn resolve_typedef(cursor: &Type, parser: &mut Parser<'_>) -> metadat
     } else if decl.is_from_main_file() && parser.symbols.is_empty() {
         metadata::Type::value_named(parser.namespace, &name)
     } else {
-        parser.pending_typedefs.push(decl);
+        parser.pending_declarations.push(decl);
         metadata::Type::value_named(parser.namespace, &name)
     }
 }

crates/libs/clang/src/cx.rs

@@ -688,6 +688,21 @@ impl Type {
         self.function_pointee().is_some()
     }
 
+    pub fn is_incomplete_record(&self) -> bool {
+        let ty = self.canonical_type();
+        ty.kind() == CXType_Record && !ty.ty().has_definition()
+    }
+
+    fn incomplete_record_name(&self, parser: &Parser<'_>) -> Option<String> {
+        let ty = self.canonical_type();
+        if ty.kind() != CXType_Record || ty.ty().has_definition() {
+            return None;
+        }
+        let decl = ty.ty();
+        let tag = decl.name();
+        Some(parser.tag_rename.get(&tag).cloned().unwrap_or(tag))
+    }
+
     pub fn function_pointee(&self) -> Option<Self> {
         match self.kind() {
             // Function-type typedefs emit as callbacks like pointer typedefs.
@@ -866,17 +881,25 @@ impl Type {
                         .to_string()
                 };
                 let definition = decl.definition();
-                if self.kind() == CXType_Record
+                if matches!(self.kind(), CXType_Record | CXType_Enum)
                     && parser.header_root.is_none()
                     && ns == parser.namespace
                     && decl.has_definition()
                     && (!definition.is_from_main_file() || !parser.symbols.is_empty())
                 {
-                    parser.pending_records.push(definition);
+                    parser.pending_declarations.push(definition);
+                } else if self.kind() == CXType_Enum
+                    && parser.header_root.is_none()
+                    && ns == parser.namespace
+                    && !decl.has_definition()
+                {
+                    if let Some((_, repr)) = enum_repr_type(decl) {
+                        parser.pending_enum_aliases.push((name.clone(), repr));
+                    } else {
+                        parser.pending_invalid_enums.push(decl);
+                    }
                 }
-                // Incomplete namespaced records remain unresolved. Deciding whether a particular
-                // use can be represented by an opaque declaration requires usage-shape analysis.
-                // Pointer-only incomplete records need an opaque forward declaration target.
+                // Per-header pointer-only records need an opaque target in their owning partition.
                 if parser.header_root.is_some()
                     && !is_anonymous_name(&name)
                     && !name.ends_with("__")
@@ -924,6 +947,14 @@ impl Type {
                     return pointee.to_type(parser);
                 }
                 let inner = pointee.to_type(parser);
+                if parser.header_root.is_none()
+                    && pointee.is_incomplete_record()
+                    && let metadata::Type::ValueName(name) = &inner
+                    && name.namespace == parser.namespace
+                    && let Some(name) = pointee.incomplete_record_name(parser)
+                {
+                    parser.pending_opaque_records.push(name);
+                }
                 if pointee.is_const() {
                     match inner {
                         metadata::Type::PtrConst(t, n) => metadata::Type::PtrConst(t, n + 1),
@@ -945,6 +976,14 @@ impl Type {
                     return pointee.to_type(parser);
                 }
                 let inner = pointee.to_type(parser);
+                if parser.header_root.is_none()
+                    && pointee.is_incomplete_record()
+                    && let metadata::Type::ValueName(name) = &inner
+                    && name.namespace == parser.namespace
+                    && let Some(name) = pointee.incomplete_record_name(parser)
+                {
+                    parser.pending_opaque_records.push(name);
+                }
                 if pointee.is_const() {
                     match inner {
                         metadata::Type::PtrConst(t, n) => metadata::Type::PtrConst(t, n + 1),

crates/libs/clang/src/enum.rs

@@ -12,17 +12,9 @@ pub struct Enum {
 
 impl Enum {
     pub fn parse(cursor: Cursor) -> Result<Self, Error> {
-        let repr = match cursor.enum_repr().kind() {
-            CXType_Int | CXType_Long => "i32",
-            CXType_UInt | CXType_ULong => "u32",
-            CXType_Short => "i16",
-            CXType_UShort => "u16",
-            CXType_Char_S | CXType_SChar => "i8",
-            CXType_Char_U | CXType_UChar => "u8",
-            CXType_LongLong => "i64",
-            CXType_ULongLong => "u64",
-            _ => "i32",
-        };
+        let (repr, _) = enum_repr_type(cursor).ok_or_else(|| {
+            Error::new("unsupported enum representation", &cursor.file_name(), 0, 0)
+        })?;
 
         let name = cursor.name();
         let scoped = cursor.is_scoped_enum();
@@ -100,3 +92,17 @@ impl Enum {
         })
     }
 }
+
+pub(crate) fn enum_repr_type(cursor: Cursor) -> Option<(&'static str, metadata::Type)> {
+    Some(match cursor.enum_repr().canonical_type().kind() {
+        CXType_Int | CXType_Long => ("i32", metadata::Type::I32),
+        CXType_UInt | CXType_ULong => ("u32", metadata::Type::U32),
+        CXType_Short => ("i16", metadata::Type::I16),
+        CXType_UShort => ("u16", metadata::Type::U16),
+        CXType_Char_S | CXType_SChar => ("i8", metadata::Type::I8),
+        CXType_Char_U | CXType_UChar => ("u8", metadata::Type::U8),
+        CXType_LongLong => ("i64", metadata::Type::I64),
+        CXType_ULongLong => ("u64", metadata::Type::U64),
+        _ => return None,
+    })
+}