Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

deps: Update syn to 2.0 #961

Closed
wants to merge 5 commits into from
Closed

deps: Update syn to 2.0 #961

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
e7b4ab8
deps: Update syn to 2.0
GrayJack May 20, 2024
083d4b1
fix: Fix parsing repr attribute
GrayJack May 21, 2024
2f52363
fix: Fix and simplify cfg parsing
GrayJack May 22, 2024
ab6d13d
fix: The variadic information now is found on its own field, outside …
GrayJack May 22, 2024
189089c
fix: Fix wrong self type on custom self parameter
GrayJack May 25, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 5 additions & 16 deletions Cargo.lock
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

2 changes: 1 addition & 1 deletion Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,7 @@ quote = "1"
heck = "0.4"

[dependencies.syn]
version = "1.0.88"
version = "2.0.64"
default-features = false
features = ["clone-impls", "extra-traits", "fold", "full", "parsing", "printing"]

Expand Down
115 changes: 55 additions & 60 deletions src/bindgen/ir/cfg.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,6 +81,52 @@ impl fmt::Display for Cfg {
}
}

impl syn::parse::Parse for Cfg {
fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
let arg: syn::Meta = input.parse()?;

match arg {
syn::Meta::Path(path) => path
.get_ident()
.map(|ident| Cfg::Boolean(ident.to_string()))
.ok_or_else(|| input.error("path must be identifier")),
syn::Meta::NameValue(syn::MetaNameValue {
path,
value:
syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(lit),
..
}),
..
}) => path
.get_ident()
.map(|ident| Cfg::Named(ident.to_string(), lit.value()))
.ok_or_else(|| input.error("path must be identifier")),
syn::Meta::List(meta) => {
if meta.path.is_ident("not") {
let cfg = meta.parse_args()?;
Ok(Cfg::Not(Box::new(cfg)))
} else if meta.path.is_ident("all") {
let cfgs = meta.parse_args_with(
syn::punctuated::Punctuated::<Cfg, syn::Token![,]>::parse_terminated,
)?;

Ok(Cfg::All(cfgs.into_iter().collect()))
} else if meta.path.is_ident("any") {
let cfgs = meta.parse_args_with(
syn::punctuated::Punctuated::<Cfg, syn::Token![,]>::parse_terminated,
)?;

Ok(Cfg::Any(cfgs.into_iter().collect()))
} else {
Err(input.error("invalid list argument"))
}
}
_ => Err(input.error("Failed to parse cfg")),
}
}
}

impl Cfg {
pub fn join(cfgs: &[Cfg]) -> Option<Cfg> {
if cfgs.is_empty() {
Expand All @@ -103,12 +149,14 @@ impl Cfg {
let mut configs = Vec::new();

for attr in attrs {
if let Ok(syn::Meta::List(syn::MetaList { path, nested, .. })) = attr.parse_meta() {
if !path.is_ident("cfg") || nested.len() != 1 {
if let syn::Meta::List(meta @ syn::MetaList { path, .. }) = &attr.meta {
if !path.is_ident("cfg") {
continue;
}

if let Some(config) = Cfg::load_single(nested.first().unwrap()) {
let cfg = meta.parse_args().ok();

if let Some(config) = cfg {
configs.push(config);
}
}
Expand All @@ -126,73 +174,20 @@ impl Cfg {
match syn::parse_str::<syn::Meta>(target) {
Ok(target) => {
// Parsing succeeded using the #[cfg] syntax
if let syn::Meta::List(syn::MetaList { path, nested, .. }) = target {
if !path.is_ident("cfg") || nested.len() != 1 {
if let syn::Meta::List(meta) = target {
if !meta.path.is_ident("cfg") {
return None;
}
Cfg::load_single(nested.first().unwrap())
meta.parse_args().ok()
} else {
None
}
}
Err(_) => {
// Parsing failed using #[cfg], this may be a literal target
// name
Cfg::load_single(&syn::NestedMeta::Lit(syn::Lit::Str(syn::LitStr::new(
target,
proc_macro2::Span::call_site(),
))))
}
}
}

fn load_single(item: &syn::NestedMeta) -> Option<Cfg> {
Some(match *item {
syn::NestedMeta::Meta(syn::Meta::Path(ref path)) => {
Cfg::Boolean(format!("{}", path.segments.first().unwrap().ident))
Some(Cfg::Boolean(target.clone()))
}
syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue {
ref path,
lit: syn::Lit::Str(ref value),
..
})) => Cfg::Named(
format!("{}", path.segments.first().unwrap().ident),
value.value(),
),
syn::NestedMeta::Meta(syn::Meta::List(syn::MetaList {
ref path,
ref nested,
..
})) => {
if path.is_ident("any") {
Cfg::Any(Cfg::load_list(nested.iter())?)
} else if path.is_ident("all") {
Cfg::All(Cfg::load_list(nested.iter())?)
} else if path.is_ident("not") {
if nested.len() != 1 {
return None;
}

Cfg::Not(Box::new(Cfg::load_single(&nested[0])?))
} else {
return None;
}
}
_ => return None,
})
}

fn load_list<'a, I: Iterator<Item = &'a syn::NestedMeta>>(attrs: I) -> Option<Vec<Cfg>> {
let mut configs = Vec::new();

for attr in attrs {
configs.push(Cfg::load_single(attr)?);
}

if configs.is_empty() {
None
} else {
Some(configs)
}
}
}
Expand Down
26 changes: 16 additions & 10 deletions src/bindgen/ir/constant.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -314,16 +314,22 @@ impl Literal {
syn::BinOp::Ne(..) => "!=",
syn::BinOp::Ge(..) => ">=",
syn::BinOp::Gt(..) => ">",
syn::BinOp::AddEq(..) => "+=",
syn::BinOp::SubEq(..) => "-=",
syn::BinOp::MulEq(..) => "*=",
syn::BinOp::DivEq(..) => "/=",
syn::BinOp::RemEq(..) => "%=",
syn::BinOp::BitXorEq(..) => "^=",
syn::BinOp::BitAndEq(..) => "&=",
syn::BinOp::BitOrEq(..) => "|=",
syn::BinOp::ShlEq(..) => "<<=",
syn::BinOp::ShrEq(..) => ">>=",
syn::BinOp::AddAssign(..) => "+=",
syn::BinOp::SubAssign(..) => "-=",
syn::BinOp::MulAssign(..) => "*=",
syn::BinOp::DivAssign(..) => "/=",
syn::BinOp::RemAssign(..) => "%=",
syn::BinOp::BitXorAssign(..) => "^=",
syn::BinOp::BitAndAssign(..) => "&=",
syn::BinOp::BitOrAssign(..) => "|=",
syn::BinOp::ShlAssign(..) => "<<=",
syn::BinOp::ShrAssign(..) => ">>=",
currently_unknown => {
return Err(format!(
"unsupported binary operator: {:?}",
currently_unknown
))
}
};
Ok(Literal::BinOp {
left: Box::new(l),
Expand Down
50 changes: 44 additions & 6 deletions src/bindgen/ir/function.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,14 @@ impl Function {
) -> Result<Function, String> {
let mut args = sig.inputs.iter().try_skip_map(|x| x.as_argument())?;

if let Some(var) = sig.variadic.as_ref() {
let arg = var.as_argument()?;

if let Some(arg) = arg {
args.push(arg);
}
}

let (mut ret, never_return) = Type::load_from_output(&sig.output)?;

if let Some(self_path) = self_type_path {
Expand Down Expand Up @@ -218,19 +226,25 @@ trait SynFnArgHelpers {
fn as_argument(&self) -> Result<Option<FunctionArgument>, String>;
}

fn gen_self_type(receiver: &syn::Receiver) -> Type {
let self_ty = Type::Path(GenericPath::self_path());
fn gen_self_type(receiver: &syn::Receiver) -> Result<Type, String> {
let mut self_ty = Type::Path(GenericPath::self_path());

// Custom self type
if receiver.colon_token.is_some() {
self_ty = Type::load(receiver.ty.as_ref())?.unwrap_or(self_ty);
}

if receiver.reference.is_none() {
return self_ty;
return Ok(self_ty);
}

let is_const = receiver.mutability.is_none();
Type::Ptr {
Ok(Type::Ptr {
ty: Box::new(self_ty),
is_const,
is_nullable: false,
is_ref: false,
}
})
}

impl SynFnArgHelpers for syn::FnArg {
Expand Down Expand Up @@ -266,9 +280,33 @@ impl SynFnArgHelpers for syn::FnArg {
}
syn::FnArg::Receiver(ref receiver) => Ok(Some(FunctionArgument {
name: Some("self".to_string()),
ty: gen_self_type(receiver),
ty: gen_self_type(receiver)?,
array_length: None,
})),
}
}
}

impl SynFnArgHelpers for syn::Variadic {
fn as_argument(&self) -> Result<Option<FunctionArgument>, String> {
let pat = self.pat.clone().map(|p| p.0);
let name = match pat.as_deref() {
Some(syn::Pat::Wild(..)) => None,
Some(syn::Pat::Ident(syn::PatIdent { ref ident, .. })) => {
Some(ident.unraw().to_string())
}
_ => {
return Err(format!(
"Parameter has an unsupported argument name: {:?}",
pat
))
}
};

Ok(Some(FunctionArgument {
name,
ty: Type::Primitive(super::PrimitiveType::VaList),
array_length: None,
}))
}
}
2 changes: 1 addition & 1 deletion src/bindgen/ir/global.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,7 +34,7 @@ impl Static {
Ok(Static::new(
path,
ty.unwrap(),
item.mutability.is_some(),
matches!(item.mutability, syn::StaticMutability::Mut(_)),
Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
AnnotationSet::load(&item.attrs)?,
Documentation::load(&item.attrs),
Expand Down
Loading
Loading