Patch-Source: https://github.com/chimera-linux/cports/blob/899c997/contrib/thunderbird/patches/llvm18-bindgen.patch https://github.com/rust-lang/rust-bindgen/pull/2689 -- diff --git a/ir/item.rs b/ir/item.rs index 40f6f7d..87d09da 100644 --- a/third_party/rust/bindgen/ir/item.rs +++ b/third_party/rust/bindgen/ir/item.rs @@ -6,8 +6,8 @@ use super::annotations::Annotations; use super::comp::{CompKind, MethodKind}; use super::context::{BindgenContext, ItemId, PartialType, TypeId}; use super::derive::{ - CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq, - CanDeriveHash, CanDeriveOrd, CanDerivePartialEq, CanDerivePartialOrd, + CanDeriveCopy, CanDeriveDebug, CanDeriveDefault, CanDeriveEq, CanDeriveHash, CanDeriveOrd, + CanDerivePartialEq, CanDerivePartialOrd, }; use super::dot::DotAttributes; use super::function::{Function, FunctionKind}; @@ -59,10 +59,7 @@ pub trait ItemCanonicalPath { /// Get the namespace-aware canonical path for this item. This means that if /// namespaces are disabled, you'll get a single item, and otherwise you get /// the whole path. - fn namespace_aware_canonical_path( - &self, - ctx: &BindgenContext, - ) -> Vec; + fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec; /// Get the canonical path for this item. fn canonical_path(&self, ctx: &BindgenContext) -> Vec; @@ -159,11 +156,7 @@ where { type Extra = (); - fn as_template_param( - &self, - ctx: &BindgenContext, - _: &(), - ) -> Option { + fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option { ctx.resolve_item((*self).into()).as_template_param(ctx, &()) } } @@ -171,11 +164,7 @@ where impl AsTemplateParam for Item { type Extra = (); - fn as_template_param( - &self, - ctx: &BindgenContext, - _: &(), - ) -> Option { + fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option { self.kind.as_template_param(ctx, self) } } @@ -183,16 +172,10 @@ impl AsTemplateParam for Item { impl AsTemplateParam for ItemKind { type Extra = Item; - fn as_template_param( - &self, - ctx: &BindgenContext, - item: &Item, - ) -> Option { + fn as_template_param(&self, ctx: &BindgenContext, item: &Item) -> Option { match *self { ItemKind::Type(ref ty) => ty.as_template_param(ctx, item), - ItemKind::Module(..) | - ItemKind::Function(..) | - ItemKind::Var(..) => None, + ItemKind::Module(..) | ItemKind::Function(..) | ItemKind::Var(..) => None, } } } @@ -214,10 +197,7 @@ impl ItemCanonicalPath for T where T: Copy + Into, { - fn namespace_aware_canonical_path( - &self, - ctx: &BindgenContext, - ) -> Vec { + fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec { debug_assert!( ctx.in_codegen_phase(), "You're not supposed to call this yet" @@ -282,9 +262,7 @@ impl Trace for Item { // There are some types, like resolved type references, where we // don't want to stop collecting types even though they may be // opaque. - if ty.should_be_traced_unconditionally() || - !self.is_opaque(ctx, &()) - { + if ty.should_be_traced_unconditionally() || !self.is_opaque(ctx, &()) { ty.trace(ctx, tracer, self); } } @@ -450,11 +428,7 @@ impl Item { } /// Construct a new opaque item type. - pub fn new_opaque_type( - with_id: ItemId, - ty: &clang::Type, - ctx: &mut BindgenContext, - ) -> TypeId { + pub fn new_opaque_type(with_id: ItemId, ty: &clang::Type, ctx: &mut BindgenContext) -> TypeId { let location = ty.declaration().location(); let ty = Opaque::from_clang_ty(ty, ctx); let kind = ItemKind::Type(ty); @@ -497,12 +471,11 @@ impl Item { self.ancestors(ctx) .filter(|id| { ctx.resolve_item(*id).as_module().map_or(false, |module| { - !module.is_inline() || - ctx.options().conservative_inline_namespaces + !module.is_inline() || ctx.options().conservative_inline_namespaces }) }) - .count() + - 1 + .count() + + 1 } /// Get this `Item`'s comment, if it has any, already preprocessed and with @@ -577,9 +550,9 @@ impl Item { pub fn is_toplevel(&self, ctx: &BindgenContext) -> bool { // FIXME: Workaround for some types falling behind when parsing weird // stl classes, for example. - if ctx.options().enable_cxx_namespaces && - self.kind().is_module() && - self.id() != ctx.root_module() + if ctx.options().enable_cxx_namespaces + && self.kind().is_module() + && self.id() != ctx.root_module() { return false; } @@ -593,9 +566,7 @@ impl Item { if parent_item.id() == ctx.root_module() { return true; - } else if ctx.options().enable_cxx_namespaces || - !parent_item.kind().is_module() - { + } else if ctx.options().enable_cxx_namespaces || !parent_item.kind().is_module() { return false; } @@ -656,15 +627,13 @@ impl Item { let path = self.path_for_allowlisting(ctx); let name = path[1..].join("::"); - ctx.options().blocklisted_items.matches(&name) || - match self.kind { + ctx.options().blocklisted_items.matches(&name) + || match self.kind { ItemKind::Type(..) => { - ctx.options().blocklisted_types.matches(&name) || - ctx.is_replaced_type(path, self.id) - } - ItemKind::Function(..) => { - ctx.options().blocklisted_functions.matches(&name) + ctx.options().blocklisted_types.matches(&name) + || ctx.is_replaced_type(path, self.id) } + ItemKind::Function(..) => ctx.options().blocklisted_functions.matches(&name), // TODO: Add constant / namespace blocklisting? ItemKind::Var(..) | ItemKind::Module(..) => false, } @@ -723,12 +692,7 @@ impl Item { } /// Helper function for full_disambiguated_name - fn push_disambiguated_name( - &self, - ctx: &BindgenContext, - to: &mut String, - level: u8, - ) { + fn push_disambiguated_name(&self, ctx: &BindgenContext, to: &mut String, level: u8) { to.push_str(&self.canonical_name(ctx)); if let ItemKind::Type(ref ty) = *self.kind() { if let TypeKind::TemplateInstantiation(ref inst) = *ty.kind() { @@ -791,16 +755,14 @@ impl Item { match *self.kind() { ItemKind::Var(ref var) => var.name().to_owned(), - ItemKind::Module(ref module) => { - module.name().map(ToOwned::to_owned).unwrap_or_else(|| { - format!("_bindgen_mod_{}", self.exposed_id(ctx)) - }) - } - ItemKind::Type(ref ty) => { - ty.sanitized_name(ctx).map(Into::into).unwrap_or_else(|| { - format!("_bindgen_ty_{}", self.exposed_id(ctx)) - }) - } + ItemKind::Module(ref module) => module + .name() + .map(ToOwned::to_owned) + .unwrap_or_else(|| format!("_bindgen_mod_{}", self.exposed_id(ctx))), + ItemKind::Type(ref ty) => ty + .sanitized_name(ctx) + .map(Into::into) + .unwrap_or_else(|| format!("_bindgen_ty_{}", self.exposed_id(ctx))), ItemKind::Function(ref fun) => { let mut name = fun.name().to_owned(); @@ -839,11 +801,7 @@ impl Item { /// If `BindgenOptions::disable_nested_struct_naming` is true then returned /// name is the inner most non-anonymous name plus all the anonymous base names /// that follows. - pub fn real_canonical_name( - &self, - ctx: &BindgenContext, - opt: &NameOptions, - ) -> String { + pub fn real_canonical_name(&self, ctx: &BindgenContext, opt: &NameOptions) -> String { let target = ctx.resolve_item(self.name_target(ctx)); // Short-circuit if the target has an override, and just use that. @@ -874,9 +832,7 @@ impl Item { }) .filter(|id| { if !ctx.options().conservative_inline_namespaces { - if let ItemKind::Module(ref module) = - *ctx.resolve_item(*id).kind() - { + if let ItemKind::Module(ref module) = *ctx.resolve_item(*id).kind() { return !module.is_inline(); } } @@ -947,9 +903,9 @@ impl Item { let ty_kind = self.kind().as_type().map(|t| t.kind()); if let Some(ty_kind) = ty_kind { match *ty_kind { - TypeKind::Comp(..) | - TypeKind::TemplateInstantiation(..) | - TypeKind::Enum(..) => return self.local_id(ctx).to_string(), + TypeKind::Comp(..) | TypeKind::TemplateInstantiation(..) | TypeKind::Enum(..) => { + return self.local_id(ctx).to_string() + } _ => {} } } @@ -990,8 +946,7 @@ impl Item { match *type_.kind() { TypeKind::Enum(ref enum_) => { - enum_.computed_enum_variation(ctx, self) == - EnumVariation::ModuleConsts + enum_.computed_enum_variation(ctx, self) == EnumVariation::ModuleConsts } TypeKind::Alias(inner_id) => { // TODO(emilio): Make this "hop through type aliases that aren't @@ -1018,18 +973,12 @@ impl Item { ItemKind::Type(_) => cc.types(), ItemKind::Function(ref f) => match f.kind() { FunctionKind::Function => cc.functions(), - FunctionKind::Method(MethodKind::Constructor) => { - cc.constructors() - } - FunctionKind::Method(MethodKind::Destructor) | - FunctionKind::Method(MethodKind::VirtualDestructor { - .. - }) => cc.destructors(), - FunctionKind::Method(MethodKind::Static) | - FunctionKind::Method(MethodKind::Normal) | - FunctionKind::Method(MethodKind::Virtual { .. }) => { - cc.methods() - } + FunctionKind::Method(MethodKind::Constructor) => cc.constructors(), + FunctionKind::Method(MethodKind::Destructor) + | FunctionKind::Method(MethodKind::VirtualDestructor { .. }) => cc.destructors(), + FunctionKind::Method(MethodKind::Static) + | FunctionKind::Method(MethodKind::Normal) + | FunctionKind::Method(MethodKind::Virtual { .. }) => cc.methods(), }, } } @@ -1041,14 +990,9 @@ impl Item { .borrow_with(|| self.compute_path(ctx, UserMangled::No)) } - fn compute_path( - &self, - ctx: &BindgenContext, - mangled: UserMangled, - ) -> Vec { + fn compute_path(&self, ctx: &BindgenContext, mangled: UserMangled) -> Vec { if let Some(path) = self.annotations().use_instead_of() { - let mut ret = - vec![ctx.resolve_item(ctx.root_module()).name(ctx).get()]; + let mut ret = vec![ctx.resolve_item(ctx.root_module()).name(ctx).get()]; ret.extend_from_slice(path); return ret; } @@ -1059,10 +1003,9 @@ impl Item { .chain(iter::once(ctx.root_module().into())) .map(|id| ctx.resolve_item(id)) .filter(|item| { - item.id() == target.id() || - item.as_module().map_or(false, |module| { - !module.is_inline() || - ctx.options().conservative_inline_namespaces + item.id() == target.id() + || item.as_module().map_or(false, |module| { + !module.is_inline() || ctx.options().conservative_inline_namespaces }) }) .map(|item| { @@ -1123,9 +1066,9 @@ impl IsOpaque for Item { ctx.in_codegen_phase(), "You're not supposed to call this yet" ); - self.annotations.opaque() || - self.as_type().map_or(false, |ty| ty.is_opaque(ctx, self)) || - ctx.opaque_by_name(self.path_for_allowlisting(ctx)) + self.annotations.opaque() + || self.as_type().map_or(false, |ty| ty.is_opaque(ctx, self)) + || ctx.opaque_by_name(self.path_for_allowlisting(ctx)) } } @@ -1225,11 +1168,7 @@ impl HasFloat for Item { pub type ItemSet = BTreeSet; impl DotAttributes for Item { - fn dot_attributes( - &self, - ctx: &BindgenContext, - out: &mut W, - ) -> io::Result<()> + fn dot_attributes(&self, ctx: &BindgenContext, out: &mut W) -> io::Result<()> where W: io::Write, { @@ -1306,17 +1245,10 @@ fn visit_child( } impl Item { - pub(crate) fn builtin_type( - kind: TypeKind, - is_const: bool, - ctx: &mut BindgenContext, - ) -> TypeId { + pub(crate) fn builtin_type(kind: TypeKind, is_const: bool, ctx: &mut BindgenContext) -> TypeId { // Feel free to add more here, I'm just lazy. match kind { - TypeKind::Void | - TypeKind::Int(..) | - TypeKind::Pointer(..) | - TypeKind::Float(..) => {} + TypeKind::Void | TypeKind::Int(..) | TypeKind::Pointer(..) | TypeKind::Float(..) => {} _ => panic!("Unsupported builtin type"), } @@ -1428,52 +1360,44 @@ impl Item { } // Guess how does clang treat extern "C" blocks? - if cursor.kind() == CXCursor_UnexposedDecl { - Err(ParseError::Recurse) - } else { + match cursor.kind() { + // On Clang 18+, extern "C" is reported accurately as a LinkageSpec. + // Older LLVM treat it as UnexposedDecl. + CXCursor_LinkageSpec | CXCursor_UnexposedDecl => Err(ParseError::Recurse), // We allowlist cursors here known to be unhandled, to prevent being // too noisy about this. - match cursor.kind() { - CXCursor_MacroDefinition | - CXCursor_MacroExpansion | - CXCursor_UsingDeclaration | - CXCursor_UsingDirective | - CXCursor_StaticAssert | - CXCursor_FunctionTemplate => { - debug!( - "Unhandled cursor kind {:?}: {:?}", - cursor.kind(), - cursor - ); - } - CXCursor_InclusionDirective => { - let file = cursor.get_included_file_name(); - match file { - None => { - warn!( - "Inclusion of a nameless file in {:?}", - cursor - ); - } - Some(filename) => { - ctx.include_file(filename); - } - } - } - _ => { - // ignore toplevel operator overloads - let spelling = cursor.spelling(); - if !spelling.starts_with("operator") { - warn!( - "Unhandled cursor kind {:?}: {:?}", - cursor.kind(), - cursor - ); - } - } + CXCursor_MacroDefinition + | CXCursor_MacroExpansion + | CXCursor_UsingDeclaration + | CXCursor_UsingDirective + | CXCursor_StaticAssert + | CXCursor_FunctionTemplate => { + debug!("Unhandled cursor kind {:?}: {:?}", cursor.kind(), cursor); + Err(ParseError::Continue) } - Err(ParseError::Continue) + CXCursor_InclusionDirective => { + let file = cursor.get_included_file_name(); + match file { + None => { + warn!("Inclusion of a nameless file in {:?}", cursor); + } + Some(included_file) => { + for cb in &ctx.options().parse_callbacks { + cb.include_file(&included_file); + } + } + } + Err(ParseError::Continue) + } + _ => { + // ignore toplevel operator overloads + let spelling = cursor.spelling(); + if !spelling.starts_with("operator") { + warn!("Unhandled cursor kind {:?}: {:?}", cursor.kind(), cursor); + } + Err(ParseError::Continue) + } } } @@ -1511,22 +1435,11 @@ impl Item { if ctx.collected_typerefs() { debug!("refs already collected, resolving directly"); - return Item::from_ty_with_id( - potential_id, - &ty, - location, - parent_id, - ctx, - ) - .unwrap_or_else(|_| Item::new_opaque_type(potential_id, &ty, ctx)); + return Item::from_ty_with_id(potential_id, &ty, location, parent_id, ctx) + .unwrap_or_else(|_| Item::new_opaque_type(potential_id, &ty, ctx)); } - if let Some(ty) = ctx.builtin_or_resolved_ty( - potential_id, - parent_id, - &ty, - Some(location), - ) { + if let Some(ty) = ctx.builtin_or_resolved_ty(potential_id, parent_id, &ty, Some(location)) { debug!("{:?} already resolved: {:?}", ty, location); return ty; } @@ -1586,12 +1499,10 @@ impl Item { id, ty, location ); - if ty.kind() == clang_sys::CXType_Unexposed || - location.cur_type().kind() == clang_sys::CXType_Unexposed + if ty.kind() == clang_sys::CXType_Unexposed + || location.cur_type().kind() == clang_sys::CXType_Unexposed { - if ty.is_associated_type() || - location.cur_type().is_associated_type() - { + if ty.is_associated_type() || location.cur_type().is_associated_type() { return Ok(Item::new_opaque_type(id, ty, ctx)); } @@ -1618,8 +1529,7 @@ impl Item { }; let comment = decl.raw_comment().or_else(|| location.raw_comment()); - let annotations = - Annotations::new(&decl).or_else(|| Annotations::new(&location)); + let annotations = Annotations::new(&decl).or_else(|| Annotations::new(&location)); if let Some(ref annotations) = annotations { if let Some(replaced) = annotations.use_instead_of() { @@ -1627,9 +1537,7 @@ impl Item { } } - if let Some(ty) = - ctx.builtin_or_resolved_ty(id, parent_id, ty, Some(location)) - { + if let Some(ty) = ctx.builtin_or_resolved_ty(id, parent_id, ty, Some(location)) { return Ok(ty); } @@ -1665,9 +1573,7 @@ impl Item { let result = Type::from_clang_ty(id, ty, location, parent_id, ctx); let relevant_parent_id = parent_id.unwrap_or(current_module); let ret = match result { - Ok(ParseResult::AlreadyResolved(ty)) => { - Ok(ty.as_type_id_unchecked()) - } + Ok(ParseResult::AlreadyResolved(ty)) => Ok(ty.as_type_id_unchecked()), Ok(ParseResult::New(item, declaration)) => { ctx.add_item( Item::new( @@ -1698,13 +1604,10 @@ impl Item { assert_eq!(*finished.decl(), declaration_to_look_for); } - location.visit(|cur| { - visit_child(cur, id, ty, parent_id, ctx, &mut result) - }); + location.visit(|cur| visit_child(cur, id, ty, parent_id, ctx, &mut result)); if valid_decl { - let partial_ty = - PartialType::new(declaration_to_look_for, id); + let partial_ty = PartialType::new(declaration_to_look_for, id); ctx.begin_parsing(partial_ty); } @@ -1813,10 +1716,7 @@ impl Item { // but maintaining these scopes properly would require more changes to // the whole libclang -> IR parsing code. - fn is_template_with_spelling( - refd: &clang::Cursor, - spelling: &str, - ) -> bool { + fn is_template_with_spelling(refd: &clang::Cursor, spelling: &str) -> bool { lazy_static! { static ref ANON_TYPE_PARAM_RE: regex::Regex = regex::Regex::new(r"^type\-parameter\-\d+\-\d+$").unwrap(); @@ -1838,11 +1738,7 @@ impl Item { } else if location.kind() == clang_sys::CXCursor_TypeRef { // Situation (2) match location.referenced() { - Some(refd) - if is_template_with_spelling(&refd, &ty_spelling) => - { - refd - } + Some(refd) if is_template_with_spelling(&refd, &ty_spelling) => refd, _ => return None, } } else { @@ -1851,16 +1747,11 @@ impl Item { location.visit(|child| { let child_ty = child.cur_type(); - if child_ty.kind() == clang_sys::CXCursor_TypeRef && - child_ty.spelling() == ty_spelling + if child_ty.kind() == clang_sys::CXCursor_TypeRef + && child_ty.spelling() == ty_spelling { match child.referenced() { - Some(refd) - if is_template_with_spelling( - &refd, - &ty_spelling, - ) => - { + Some(refd) if is_template_with_spelling(&refd, &ty_spelling) => { definition = Some(refd); return clang_sys::CXChildVisit_Break; } @@ -1883,12 +1774,7 @@ impl Item { if let Some(id) = ctx.get_type_param(&definition) { if let Some(with_id) = with_id { - return Some(ctx.build_ty_wrapper( - with_id, - id, - Some(parent), - &ty, - )); + return Some(ctx.build_ty_wrapper(with_id, id, Some(parent), &ty)); } else { return Some(id); } @@ -1920,8 +1806,8 @@ impl ItemCanonicalName for Item { ); self.canonical_name .borrow_with(|| { - let in_namespace = ctx.options().enable_cxx_namespaces || - ctx.options().disable_name_namespacing; + let in_namespace = + ctx.options().enable_cxx_namespaces || ctx.options().disable_name_namespacing; if in_namespace { self.name(ctx).within_namespaces().get() @@ -1934,10 +1820,7 @@ impl ItemCanonicalName for Item { } impl ItemCanonicalPath for Item { - fn namespace_aware_canonical_path( - &self, - ctx: &BindgenContext, - ) -> Vec { + fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec { let mut path = self.canonical_path(ctx); // ASSUMPTION: (disable_name_namespacing && cxx_namespaces)