Merge pull request #756 from carlossless

Add config option to override method argument and return type null-ability.

Author: madsmtm

crates/header-translator/src/config.rs

@@ -572,6 +572,22 @@ pub struct CategoryData {
     pub renamed: Option<String>,
 }
 
+#[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+#[serde(rename_all = "lowercase")]
+pub enum Nullability {
+    #[default]
+    Nullable,
+    NonNull,
+}
+
+#[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct TypeOverride {
+    #[serde(default)]
+    pub nullability: Option<Nullability>,
+}
+
 #[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
 #[serde(deny_unknown_fields)]
 pub struct MethodData {
@@ -582,6 +598,12 @@ pub struct MethodData {
     #[serde(rename = "unsafe")]
     #[serde(default)]
     pub unsafe_: Unsafe,
+    #[serde(default)]
+    #[serde(deserialize_with = "deserialize_argument_overrides")]
+    pub arguments: HashMap<usize, TypeOverride>,
+    #[serde(rename = "return")]
+    #[serde(default)]
+    pub return_: TypeOverride,
 }
 
 impl MethodData {
@@ -591,6 +613,8 @@ impl MethodData {
             unsafe_: self.unsafe_,
             renamed: self.renamed.or(superclass.renamed).clone(),
             skipped: self.skipped | superclass.skipped,
+            arguments: self.arguments,
+            return_: self.return_,
         }
     }
 }
@@ -689,3 +713,32 @@ impl<'de> de::Deserialize<'de> for Counterpart {
         deserializer.deserialize_str(CounterpartVisitor)
     }
 }
+
+fn deserialize_argument_overrides<'de, D>(
+    deserializer: D,
+) -> Result<HashMap<usize, TypeOverride>, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    let str_map = HashMap::<&str, TypeOverride>::deserialize(deserializer)?;
+    let original_len = str_map.len();
+    let data = {
+        str_map
+            .into_iter()
+            .map(|(str_key, value)| match str_key.parse() {
+                Ok(int_key) => Ok((int_key, value)),
+                Err(_) => Err({
+                    de::Error::invalid_value(
+                        de::Unexpected::Str(str_key),
+                        &"a non-negative integer",
+                    )
+                }),
+            })
+            .collect::<Result<HashMap<_, _>, _>>()?
+    };
+    // multiple strings could parse to the same int, e.g "0" and "00"
+    if data.len() < original_len {
+        return Err(de::Error::custom("duplicate integer key"));
+    }
+    Ok(data)
+}

crates/header-translator/src/method.rs

@@ -1,9 +1,10 @@
+use core::panic;
 use std::fmt;
 
 use clang::{Entity, EntityKind, ObjCAttributes, ObjCQualifiers};
 
 use crate::availability::Availability;
-use crate::config::MethodData;
+use crate::config::{self, MethodData, TypeOverride};
 use crate::context::Context;
 use crate::display_helper::FormatterFn;
 use crate::documentation::Documentation;
@@ -437,7 +438,8 @@ impl Method {
             .get_arguments()
             .expect("method arguments")
             .into_iter()
-            .map(|entity| {
+            .enumerate()
+            .map(|(index, entity)| {
                 let name = entity.get_name().expect("arg display name");
                 let _span = debug_span!("method argument", name).entered();
                 let qualifier = entity
@@ -473,12 +475,24 @@ impl Method {
                 });
 
                 let ty = entity.get_type().expect("argument type");
-                let ty = Ty::parse_method_argument(ty, qualifier, sendable, no_escape, context);
+                let mut ty = Ty::parse_method_argument(ty, qualifier, sendable, no_escape, context);
+
+                if let Some(ty_or) = data.arguments.get(&index) {
+                    apply_type_override(&mut ty, ty_or);
+                }
 
                 (name, ty)
             })
             .collect();
 
+        let last_arg_override = *data.arguments.keys().max().unwrap_or(&0);
+        if arguments.len() < last_arg_override {
+            panic!(
+                "argument override index out of bounds {}",
+                last_arg_override
+            );
+        }
+
         let is_error = if let Some((_, ty)) = arguments.last() {
             ty.argument_is_error_out()
         } else {
@@ -531,6 +545,8 @@ impl Method {
             modifiers.mainthreadonly,
         );
 
+        apply_type_override(&mut result_type, &data.return_);
+
         let encoding = entity
             .get_objc_type_encoding()
             .expect("method to have encoding");
@@ -605,7 +621,7 @@ impl Method {
             .expect("method to have encoding");
 
         let getter = if !getter_data.skipped {
-            let ty = Ty::parse_property_return(
+            let mut ty = Ty::parse_property_return(
                 entity.get_type().expect("property type"),
                 is_copy,
                 modifiers.sendable,
@@ -627,6 +643,8 @@ impl Method {
                 modifiers.mainthreadonly,
             );
 
+            apply_type_override(&mut ty, &getter_data.return_);
+
             Some(Method {
                 selector: getter_sel.clone(),
                 fn_name: getter_sel.clone(),
@@ -655,7 +673,7 @@ impl Method {
             let setter_data = setter_data.expect("setter_data must be present if setter_sel was");
             if !setter_data.skipped {
                 let result_type = Ty::VOID_RESULT;
-                let ty = Ty::parse_property(
+                let mut ty = Ty::parse_property(
                     entity.get_type().expect("property type"),
                     is_copy,
                     modifiers.sendable,
@@ -674,6 +692,10 @@ impl Method {
                     modifiers.mainthreadonly,
                 );
 
+                if let Some(ty_or) = setter_data.arguments.get(&0) {
+                    apply_type_override(&mut ty, ty_or);
+                }
+
                 Some(Method {
                     selector,
                     fn_name,
@@ -909,3 +931,28 @@ pub(crate) fn handle_reserved(name: &str) -> String {
         name.into()
     }
 }
+
+pub(crate) fn apply_type_override(ty: &mut Ty, or: &TypeOverride) {
+    if let Some(nullability) = &or.nullability {
+        let c_nullability = match nullability {
+            config::Nullability::Nullable => clang::Nullability::Nullable,
+            config::Nullability::NonNull => clang::Nullability::NonNull,
+        };
+
+        let check_and_set_nullability = |current_nullability: &mut clang::Nullability| {
+            if *current_nullability == c_nullability {
+                warn!("nullability already set to {:?}", current_nullability);
+            }
+            *current_nullability = c_nullability;
+        };
+
+        match ty {
+            Ty::Pointer { nullability, .. }
+            | Ty::Sel { nullability, .. }
+            | Ty::IncompleteArray { nullability, .. } => {
+                check_and_set_nullability(nullability);
+            }
+            _ => panic!("unexpected type: {:?}", ty),
+        };
+    }
+}

framework-crates/objc2-io-usb-host/translation-config.toml

@@ -5,9 +5,9 @@ custom-lib-rs = true
 macos = "10.15"
 maccatalyst = "14.0"
 
-# Return type marked as non-null, raises `unknown error result type`.
-class.IOUSBHostControllerInterface.methods."getPortStateMachineForCommand:error:".skipped = true
-class.IOUSBHostControllerInterface.methods."getPortStateMachineForPort:error:".skipped = true
+# Return type nullability is incorrectly declared in the header. It should be `nullable` instead of `nonnull`.
+class.IOUSBHostControllerInterface.methods."getPortStateMachineForCommand:error:".return.nullability = "nullable"
+class.IOUSBHostControllerInterface.methods."getPortStateMachineForPort:error:".return.nullability = "nullable"
 
 # Returns non-object pointer in error method, raises `unknown error result type`.
 class.IOUSBHostObject.methods."descriptorWithType:length:index:languageID:requestType:requestRecipient:error:".skipped = true