deps: Update syn to 2.0

The variadic function information now is found on its own field, outside
of `Signature.inputs`

Closes #961

Cargo.toml

@@ -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"]
 

src/bindgen/ir/cfg.rs

@@ -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() {
@@ -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);
                 }
             }
@@ -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)
         }
     }
 }

src/bindgen/ir/constant.rs

@@ -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),

src/bindgen/ir/function.rs

@@ -48,6 +48,13 @@ impl Function {
         mod_cfg: Option<&Cfg>,
     ) -> Result<Function, String> {
         let mut args = sig.inputs.iter().try_skip_map(|x| x.as_argument())?;
+        if sig.variadic.is_some() {
+            args.push(FunctionArgument {
+                name: None,
+                ty: Type::Primitive(super::PrimitiveType::VaList),
+                array_length: None,
+            })
+        }
 
         let (mut ret, never_return) = Type::load_from_output(&sig.output)?;
 
@@ -218,19 +225,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 {
@@ -270,7 +283,7 @@ 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,
             })),
         }

src/bindgen/ir/global.rs

@@ -36,7 +36,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),