forge/ayaports
1
0
Fork 0
Code Issues 43 Pull requests 11 Projects Releases Packages Wiki Activity Actions
ayaports/user/zotero/llvm18-bindgen.patch

620 lines
24 KiB
Diff
Raw Normal View History

user/zotero: upgrade to 7.0.0_beta109
2024-07-05 02:51:27 +00:00
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<String>;
+ fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec<String>;
/// Get the canonical path for this item.
fn canonical_path(&self, ctx: &BindgenContext) -> Vec<String>;
@@ -159,11 +156,7 @@ where
{
type Extra = ();
- fn as_template_param(
- &self,
- ctx: &BindgenContext,
- _: &(),
- ) -> Option<TypeId> {
+ fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option<TypeId> {
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<TypeId> {
+ fn as_template_param(&self, ctx: &BindgenContext, _: &()) -> Option<TypeId> {
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<TypeId> {
+ fn as_template_param(&self, ctx: &BindgenContext, item: &Item) -> Option<TypeId> {
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<T> ItemCanonicalPath for T
where
T: Copy + Into<ItemId>,
{
- fn namespace_aware_canonical_path(
- &self,
- ctx: &BindgenContext,
- ) -> Vec<String> {
+ fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
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<String> {
+ fn compute_path(&self, ctx: &BindgenContext, mangled: UserMangled) -> Vec<String> {
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<ItemId>;
impl DotAttributes for Item {
- fn dot_attributes<W>(
- &self,
- ctx: &BindgenContext,
- out: &mut W,
- ) -> io::Result<()>
+ fn dot_attributes<W>(&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<String> {
+ fn namespace_aware_canonical_path(&self, ctx: &BindgenContext) -> Vec<String> {
let mut path = self.canonical_path(ctx);
// ASSUMPTION: (disable_name_namespacing && cxx_namespaces)
Reference in a new issue Copy permalink