Added target_os cfg feature to header translator

crates/header-translator/src/availability.rs

@@ -6,14 +6,87 @@ use clang::{Entity, PlatformAvailability, Version};
 use crate::context::Context;
 
 #[derive(Debug, Clone, PartialEq, Default)]
-struct Unavailable {
-    ios: bool,
-    ios_app_extension: bool,
-    macos: bool,
-    macos_app_extension: bool,
-    maccatalyst: bool,
-    watchos: bool,
-    tvos: bool,
+pub struct Unavailable {
+    pub(crate) ios: bool,
+    pub(crate) ios_app_extension: bool,
+    pub(crate) macos: bool,
+    pub(crate) macos_app_extension: bool,
+    pub(crate) maccatalyst: bool,
+    pub(crate) watchos: bool,
+    pub(crate) tvos: bool,
+    pub(crate) library_unavailablility: Option<Box<Unavailable>>,
+}
+
+impl Unavailable {
+    fn list_unavailable_oses(&self) -> Vec<&str> {
+        let mut unavailable_oses = Vec::new();
+        if self.ios
+            && !self
+                .library_unavailablility
+                .as_ref()
+                .map(|u| u.ios)
+                .unwrap_or_else(|| false)
+        {
+            unavailable_oses.push("ios");
+        }
+        if self.macos
+            && !self
+                .library_unavailablility
+                .as_ref()
+                .map(|u| u.macos)
+                .unwrap_or_else(|| false)
+        {
+            unavailable_oses.push("macos");
+        }
+        if self.tvos
+            && !self
+                .library_unavailablility
+                .as_ref()
+                .map(|u| u.tvos)
+                .unwrap_or_else(|| false)
+        {
+            unavailable_oses.push("tvos");
+        }
+        if self.watchos
+            && !self
+                .library_unavailablility
+                .as_ref()
+                .map(|u| u.watchos)
+                .unwrap_or_else(|| false)
+        {
+            unavailable_oses.push("watchos");
+        }
+        unavailable_oses
+    }
+
+    /// In some cases of enums, we need to know the availability of the parent enum and the enum
+    /// variant.
+    pub fn merge(&self, other: &Self) -> Self {
+        Self {
+            ios: self.ios || other.ios,
+            ios_app_extension: self.ios_app_extension || other.ios_app_extension,
+            macos: self.macos || other.macos,
+            macos_app_extension: self.macos_app_extension || other.macos_app_extension,
+            tvos: self.tvos || other.tvos,
+            watchos: self.watchos || other.watchos,
+            maccatalyst: self.maccatalyst || other.maccatalyst,
+            library_unavailablility: self.library_unavailablility.clone(),
+        }
+    }
+}
+impl fmt::Display for Unavailable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let unavailable_oses = self.list_unavailable_oses();
+        let unavailable_oses = unavailable_oses
+            .iter()
+            .map(|os| format!("target_os = \"{os}\""))
+            .collect::<Vec<String>>()
+            .join(",");
+        if !unavailable_oses.is_empty() {
+            write!(f, "#[cfg(not(any({unavailable_oses})))]")?;
+        }
+        Ok(())
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Default)]
@@ -29,20 +102,27 @@ struct Versions {
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Availability {
-    unavailable: Unavailable,
+    pub(crate) unavailable: Unavailable,
     introduced: Versions,
     deprecated: Versions,
     message: Option<String>,
     _swift: Option<PlatformAvailability>,
 }
 
 impl Availability {
-    pub fn parse(entity: &Entity<'_>, _context: &Context<'_>) -> Self {
+    pub fn parse(
+        entity: &Entity<'_>,
+        _context: &Context<'_>,
+        library_unavailablility: &Unavailable,
+    ) -> Self {
         let availabilities = entity
             .get_platform_availability()
             .expect("platform availability");
 
-        let mut unavailable = Unavailable::default();
+        let mut unavailable = Unavailable {
+            library_unavailablility: Some(Box::new(library_unavailablility.clone())),
+            ..Default::default()
+        };
         let mut introduced = Versions::default();
         let mut deprecated = Versions::default();
         let mut message = None;
@@ -157,7 +237,8 @@ impl fmt::Display for Availability {
                 }
             }
         }
-        // TODO: Emit `cfg` attributes based on `self.unavailable`
+        write!(f, "{}", self.unavailable)?;
+
         // TODO: Emit availability checks based on `self.introduced`
         Ok(())
     }

crates/header-translator/src/cache.rs

@@ -164,6 +164,7 @@ impl<'a> Cache<'a> {
                     id,
                     generics,
                     superclasses,
+                    availability,
                     ..
                 } => {
                     let _span = debug_span!("Stmt::ClassDecl", ?id).entered();
@@ -203,7 +204,7 @@ impl<'a> Cache<'a> {
                                     cls: id.clone(),
                                     generics: generics.clone(),
                                     category: cache.category.clone(),
-                                    availability: cache.availability.clone(),
+                                    availability: availability.clone(),
                                     superclasses: superclasses.clone(),
                                     methods,
                                     description: Some(format!(

crates/header-translator/src/config.rs

@@ -5,6 +5,7 @@ use std::path::Path;
 
 use serde::Deserialize;
 
+use crate::availability::Unavailable;
 use crate::data;
 use crate::rust_type::Ownership;
 use crate::stmt::Derives;
@@ -81,6 +82,18 @@ pub struct LibraryData {
     #[serde(default)]
     pub watchos: Option<semver::VersionReq>,
 }
+impl LibraryData {
+    pub(crate) fn unavailability(&self) -> Unavailable {
+        Unavailable {
+            ios: self.ios.is_none(),
+            macos: self.macos.is_none(),
+            tvos: self.tvos.is_none(),
+            watchos: self.watchos.is_none(),
+            maccatalyst: self.maccatalyst.is_none(),
+            ..Default::default()
+        }
+    }
+}
 
 #[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
 #[serde(deny_unknown_fields)]

crates/header-translator/src/library.rs

@@ -4,17 +4,20 @@ use std::fs;
 use std::io;
 use std::path::Path;
 
+use crate::availability::Unavailable;
 use crate::file::{File, FILE_PRELUDE};
 
 #[derive(Debug, PartialEq, Default)]
 pub struct Library {
     pub files: BTreeMap<String, File>,
+    pub unavailability: Unavailable,
 }
 
 impl Library {
-    pub fn new() -> Self {
+    pub(crate) fn new(unavailability: Unavailable) -> Self {
         Self {
             files: BTreeMap::new(),
+            unavailability,
         }
     }
 
@@ -60,16 +63,16 @@ impl fmt::Display for Library {
             // NOTE: some SDK files have '+' in the file name
             let name = name.replace('+', "_");
             for stmt in &file.stmts {
-                let mut iter = stmt.declared_types();
-                if let Some(item) = iter.next() {
-                    // Use a set to deduplicate features, and to have them in
-                    // a consistent order
-                    let mut features = BTreeSet::new();
-                    stmt.visit_required_types(|item| {
-                        if let Some(feature) = item.feature() {
-                            features.insert(format!("feature = \"{feature}\""));
-                        }
-                    });
+                // Use a set to deduplicate features, and to have them in
+                // a consistent order
+                let mut features = BTreeSet::new();
+                stmt.visit_required_types(|item| {
+                    if let Some(feature) = item.feature() {
+                        features.insert(format!("feature = \"{feature}\""));
+                    }
+                });
+
+                for (item, unavailability) in stmt.declared_types() {
                     match features.len() {
                         0 => {}
                         1 => {
@@ -87,12 +90,8 @@ impl fmt::Display for Library {
                             )?;
                         }
                     }
-
-                    writeln!(f, "pub use self::__{name}::{{{item}")?;
-                    for item in iter {
-                        writeln!(f, ", {item}")?;
-                    }
-                    writeln!(f, "}};")?;
+                    write!(f, "{unavailability}")?;
+                    writeln!(f, "pub use self::__{name}::{{{item}}};")?;
                 }
             }
         }

crates/header-translator/src/main.rs

@@ -196,7 +196,7 @@ fn parse_sdk(index: &Index<'_>, sdk: &SdkPath, llvm_target: &str, config: &Confi
     let tu = get_translation_unit(index, sdk, llvm_target);
 
     let mut preprocessing = true;
-    let mut result = Output::from_libraries(config.libraries.keys());
+    let mut result = Output::from_libraries(&config.libraries);
 
     let mut library_span = None;
     let mut library_span_name = String::new();
@@ -269,7 +269,7 @@ fn parse_sdk(index: &Index<'_>, sdk: &SdkPath, llvm_target: &str, config: &Confi
                         preprocessing = false;
                         // No more includes / macro expansions after this line
                         let file = library.files.get_mut(&file_name).expect("file");
-                        for stmt in Stmt::parse(&entity, &context) {
+                        for stmt in Stmt::parse(&entity, &context, &library.unavailability) {
                             file.add_stmt(stmt);
                         }
                     }

crates/header-translator/src/method.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use clang::{Entity, EntityKind, ObjCAttributes, ObjCQualifiers};
 use tracing::span::EnteredSpan;
 
-use crate::availability::Availability;
+use crate::availability::{Availability, Unavailable};
 use crate::config::MethodData;
 use crate::context::Context;
 use crate::id::ItemIdentifier;
@@ -328,6 +328,7 @@ impl<'tu> PartialMethod<'tu> {
         data: MethodData,
         is_protocol: bool,
         context: &Context<'_>,
+        library_unavailablility: &Unavailable,
     ) -> Option<(bool, Method)> {
         let Self {
             entity,
@@ -346,7 +347,7 @@ impl<'tu> PartialMethod<'tu> {
             return None;
         }
 
-        let availability = Availability::parse(&entity, context);
+        let availability = Availability::parse(&entity, context, library_unavailablility);
 
         let modifiers = MethodModifiers::parse(&entity, context);
 
@@ -465,6 +466,7 @@ impl PartialProperty<'_> {
         setter_data: Option<MethodData>,
         is_protocol: bool,
         context: &Context<'_>,
+        library_unavailablility: &Unavailable,
     ) -> (Option<Method>, Option<Method>) {
         let Self {
             entity,
@@ -483,7 +485,7 @@ impl PartialProperty<'_> {
             return (None, None);
         }
 
-        let availability = Availability::parse(&entity, context);
+        let availability = Availability::parse(&entity, context, library_unavailablility);
 
         let modifiers = MethodModifiers::parse(&entity, context);
 

crates/header-translator/src/output.rs

@@ -1,7 +1,8 @@
+use std::collections::HashMap;
 use std::collections::{BTreeMap, BTreeSet};
 use std::str::FromStr;
 
-use crate::config::Config;
+use crate::config::{Config, LibraryData};
 use crate::library::Library;
 use crate::stmt::Stmt;
 
@@ -11,10 +12,10 @@ pub struct Output {
 }
 
 impl Output {
-    pub fn from_libraries(libraries: impl IntoIterator<Item = impl Into<String>>) -> Self {
+    pub fn from_libraries(libraries: &HashMap<String, LibraryData>) -> Self {
         let libraries = libraries
-            .into_iter()
-            .map(|name| (name.into(), Library::new()))
+            .iter()
+            .map(|(name, library_data)| (name.into(), Library::new(library_data.unavailability())))
             .collect();
         Self { libraries }
     }