IOUSBHostCIMessageStatus has the wrong type/encoding

[carlossless]

Hi,

I'm experiencing a panic, when trying to use [IOUSBHostCIControllerStateMachine respondToCommand:status:error:] and passing IOUSBHostCIMessageStatus::Success for the status argument. Here's the message I receive:

[IOUSBHostCIControllerStateMachine respondToCommand:status:error:]: expected argument at index 1 to have type code 'i', but found 'I'

Enabling the feature relax-sign-encoding can be a workaround, but in order to actually fix this, the ENCODING (and underlying type) for IOUSBHostCIMessageStatus should be changed from c_uint to c_int.

[carlossless]

Just encountered the same issue with:

• IOUSBHostCILinkState
• IOUSBHostCIDeviceSpeed
• IOUSBHostCIEndpointState

[madsmtm]

Indeed, the following program returns i and not I.

#import <IOUSBHost/IOUSBHost.h>

int main() {
    printf("%s\n", @encode(IOUSBHostCIMessageStatus));
    return 0;
}

I'm unsure why header-translator thinks that it should treat it as c_uint, probably some faulty logic somewhere in

objc2/crates/header-translator/src/stmt.rs

Lines 1357 to 1502 in c589b66

	EntityKind::EnumDecl => {
	// Enum declarations show up twice for some reason, but
	// luckily this flag is set on the least descriptive entity.
	if !entity.is_definition() {
	return vec![];
	}
	let ty = entity.get_enum_underlying_type().expect("enum type");
	let mut ty = Ty::parse_enum(ty, context);
	let is_signed = ty.is_signed().unwrap_or_else(|| {
	error!(?ty, "cannot determine signed-ness of enum");
	false
	});
	let mut kind = None;
	let mut variants = Vec::new();
	let mut sendable = None;
	immediate_children(entity, |entity, _span| match entity.get_kind() {
	EntityKind::EnumConstantDecl => {
	let id = ItemIdentifier::new(&entity, context);
	let const_data = context.library(&id).get(&entity);
	let availability = Availability::parse(&entity, context);
	if const_data.skipped.unwrap_or(false) {
	return;
	}
	let value = entity
	.get_enum_constant_value()
	.expect("enum constant value");
	let mut expr = if is_signed {
	Expr::Signed(value.0)
	} else {
	Expr::Unsigned(value.1)
	};
	if !(const_data.use_value.or(data.use_value).unwrap_or(false)) {
	// Some enums constants don't declare a value, but
	// let it be inferred from the position in the
	// enum instead; in those cases, we use the value
	// generated above.
	immediate_children(&entity, |entity, _span| match entity.get_kind() {
	EntityKind::UnexposedAttr => {
	if let Some(attr) = UnexposedAttr::parse(&entity, context) {
	match attr {
	UnexposedAttr::Enum
	| UnexposedAttr::Options
	| UnexposedAttr::ClosedEnum
	| UnexposedAttr::ErrorEnum => {
	if kind.as_ref() != Some(&attr) {
	error!(?kind, ?attr, "enum child had attribute that parent did not");
	}
	}
	attr => {
	error!(?attr, "unknown attribute on enum constant")
	}
	}
	}
	}
	EntityKind::VisibilityAttr => {}
	_ if entity.is_expression() => {
	expr = Expr::parse_enum_constant(&entity, context);
	}
	_ => {
	panic!("unknown EnumConstantDecl child in {id:?}: {entity:?}")
	}
	});
	};
	let documentation = Documentation::from_entity(&entity, context);
	if ty.is_simple_uint() {
	ty = expr.guess_type(id.location());
	}
	variants.push((id.name, documentation, availability, expr));
	}
	EntityKind::UnexposedAttr => {
	if let Some(attr) = UnexposedAttr::parse(&entity, context) {
	match attr {
	UnexposedAttr::Sendable => sendable = Some(true),
	UnexposedAttr::NonSendable => sendable = Some(false),
	attr => {
	if let Some(kind) = &kind {
	assert_eq!(
	kind, &attr,
	"got differing enum kinds in {id:?}"
	);
	} else {
	kind = Some(attr);
	}
	}
	}
	}
	}
	EntityKind::FlagEnum => {
	let macro_ = UnexposedAttr::Options;
	if let Some(kind) = &kind {
	assert_eq!(kind, &macro_, "got differing enum kinds in {id:?}");
	} else {
	kind = Some(macro_);
	}
	}
	EntityKind::VisibilityAttr => {
	// Already exposed as entity.get_visibility()
	}
	_ => error!("unknown"),
	});
	if id.name.is_none() {
	// Availability propagates to the variants automatically
	let _ = availability;
	// TODO: Unsure how to handle error enums
	assert!(matches!(
	kind,
	None | Some(UnexposedAttr::Enum) | Some(UnexposedAttr::ErrorEnum)
	));
	assert_eq!(sendable, None);
	let variants_len = variants.len();
	variants
	.into_iter()
	.enumerate()
	.map(
	|(i, (name, documentation, availability, value))| Self::ConstDecl {
	id: id.clone().map_name(|_| name),
	availability,
	ty: ty.clone(),
	value,
	is_last: i == variants_len - 1,
	documentation,
	},
	)
	.collect()
	} else {
	vec![Self::EnumDecl {
	id: id.map_name(|name| name.unwrap()),
	availability,
	ty,
	kind,
	variants,
	sendable,
	documentation,
	}]
	}
	}

[carlossless]

Well, clang_getEnumDeclIntegerType definitely returns unsigned int for these types, but I'm not sure what makes clang think this way...

[madsmtm]

Possibly it's the = 0 on IOUSBHostCIMessageStatusReserved? I'm unsure :/

[pronebird]

Swift also thinks it's UInt32 https://developer.apple.com/documentation/iousbhost/iousbhostcimessagestatus

[carlossless]

Hm, perhaps it's just a difference in how @encode and clang see these types and there's nothing actually wrong here.

I wonder if these cases could be detected and encoding requirements relaxed when calling methods that accept these types... 🤔

[pronebird]

@carlossless I found the following SO issue which says that the behaviour of modern C compiler has changed 🤯

[madsmtm]

Btw, I think you can work around it with:

# Cargo.toml
[dependencies]
objc2 = { version = "0.6.1", features = ["relax-sign-encoding"] }