Squashed 'third_party/autocxx/' content from commit 629e8fa53
git-subtree-dir: third_party/autocxx
git-subtree-split: 629e8fa531a633164c0b52e2a3cab536d4cd0849
Signed-off-by: Brian Silverman <bsilver16384@gmail.com>
Change-Id: I62a03b0049f49adf029e0204639cdb5468dde1a1
diff --git a/engine/src/ast_discoverer.rs b/engine/src/ast_discoverer.rs
new file mode 100644
index 0000000..8840899
--- /dev/null
+++ b/engine/src/ast_discoverer.rs
@@ -0,0 +1,726 @@
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use indexmap::set::IndexSet as HashSet;
+
+use autocxx_parser::{
+ directive_names::{EXTERN_RUST_FUN, EXTERN_RUST_TYPE},
+ RustFun, RustPath,
+};
+use itertools::Itertools;
+use proc_macro2::Ident;
+use syn::{
+ parse_quote, punctuated::Punctuated, Attribute, Binding, Expr, ExprAssign, ExprAssignOp,
+ ExprAwait, ExprBinary, ExprBox, ExprBreak, ExprCast, ExprField, ExprGroup, ExprLet, ExprParen,
+ ExprReference, ExprTry, ExprType, ExprUnary, ImplItem, Item, ItemEnum, ItemStruct, Pat, PatBox,
+ PatReference, PatSlice, PatTuple, Path, Receiver, ReturnType, Signature, Stmt, TraitItem, Type,
+ TypeArray, TypeGroup, TypeParamBound, TypeParen, TypePtr, TypeReference, TypeSlice,
+};
+use thiserror::Error;
+
+#[derive(Default)]
+pub(super) struct Discoveries {
+ pub(super) cpp_list: HashSet<String>,
+ pub(super) extern_rust_funs: Vec<RustFun>,
+ pub(super) extern_rust_types: Vec<RustPath>,
+}
+
+#[derive(Error, Debug)]
+pub enum DiscoveryErr {
+ #[error("#[extern_rust_function] was attached to a method in an impl block that was too complex for autocxx. autocxx supports only \"impl X {{...}}\" where X is a single identifier, not a path or more complex type.")]
+ FoundExternRustFunOnTypeWithoutClearReceiver,
+ #[error("#[extern_rust_function] was attached to a method taking no parameters.")]
+ NonReferenceReceiver,
+ #[error("#[extern_rust_function] was attached to a method taking a receiver by value.")]
+ NoParameterOnMethod,
+ #[error("#[extern_rust_function] was in an impl block nested wihtin another block. This is only supported in the outermost mod of a file, alongside the include_cpp!.")]
+ FoundExternRustFunWithinMod,
+}
+
+impl Discoveries {
+ pub(super) fn search_item(
+ &mut self,
+ item: &Item,
+ mod_path: Option<RustPath>,
+ ) -> Result<(), DiscoveryErr> {
+ let mut this_mod = PerModDiscoveries {
+ discoveries: self,
+ mod_path,
+ };
+ this_mod.search_item(item)
+ }
+
+ pub(crate) fn found_allowlist(&self) -> bool {
+ !self.cpp_list.is_empty()
+ }
+
+ pub(crate) fn found_rust(&self) -> bool {
+ !self.extern_rust_funs.is_empty() || !self.extern_rust_types.is_empty()
+ }
+
+ pub(crate) fn extend(&mut self, other: Self) {
+ self.cpp_list.extend(other.cpp_list);
+ self.extern_rust_funs.extend(other.extern_rust_funs);
+ self.extern_rust_types.extend(other.extern_rust_types);
+ }
+}
+
+struct PerModDiscoveries<'a> {
+ discoveries: &'a mut Discoveries,
+ mod_path: Option<RustPath>,
+}
+
+impl<'b> PerModDiscoveries<'b> {
+ fn deeper_path(&self, id: &Ident) -> RustPath {
+ match &self.mod_path {
+ None => RustPath::new_from_ident(id.clone()),
+ Some(mod_path) => mod_path.append(id.clone()),
+ }
+ }
+
+ fn search_item(&mut self, item: &Item) -> Result<(), DiscoveryErr> {
+ match item {
+ Item::Fn(fun) => {
+ for stmt in &fun.block.stmts {
+ self.search_stmt(stmt)?
+ }
+ self.search_return_type(&fun.sig.output)?;
+ for i in &fun.sig.inputs {
+ match i {
+ syn::FnArg::Receiver(_) => {}
+ syn::FnArg::Typed(pt) => {
+ self.search_pat(&pt.pat)?;
+ self.search_type(&pt.ty)?;
+ }
+ }
+ }
+ if Self::has_attr(&fun.attrs, EXTERN_RUST_FUN) {
+ self.discoveries.extern_rust_funs.push(RustFun {
+ path: self.deeper_path(&fun.sig.ident),
+ sig: fun.sig.clone(),
+ receiver: None,
+ });
+ }
+ }
+ Item::Impl(imp) => {
+ let receiver = match imp.trait_ {
+ // We do not allow 'extern_rust_fun' on trait impls
+ Some(_) => None,
+ None => match &*imp.self_ty {
+ Type::Path(typ) => {
+ let mut segs = typ.path.segments.iter();
+ let id = segs.next();
+ if let Some(seg) = id {
+ if segs.next().is_some() {
+ None
+ } else {
+ Some(self.deeper_path(&seg.ident))
+ }
+ } else {
+ None
+ }
+ }
+ _ => None,
+ },
+ };
+ for item in &imp.items {
+ self.search_impl_item(item, receiver.as_ref())?
+ }
+ }
+ Item::Mod(md) => {
+ if let Some((_, items)) = &md.content {
+ let mod_path = Some(self.deeper_path(&md.ident));
+ let mut new_mod = PerModDiscoveries {
+ discoveries: self.discoveries,
+ mod_path,
+ };
+ for item in items {
+ new_mod.search_item(item)?
+ }
+ }
+ }
+ Item::Trait(tr) => {
+ for item in &tr.items {
+ self.search_trait_item(item)?
+ }
+ }
+ Item::Struct(ItemStruct { ident, attrs, .. })
+ | Item::Enum(ItemEnum { ident, attrs, .. })
+ if Self::has_attr(attrs, EXTERN_RUST_TYPE) =>
+ {
+ self.discoveries
+ .extern_rust_types
+ .push(self.deeper_path(ident));
+ }
+ _ => {}
+ }
+ Ok(())
+ }
+
+ fn search_path(&mut self, path: &Path) -> Result<(), DiscoveryErr> {
+ let mut seg_iter = path.segments.iter();
+ if let Some(first_seg) = seg_iter.next() {
+ if first_seg.ident == "ffi" {
+ self.discoveries
+ .cpp_list
+ .insert(seg_iter.map(|seg| seg.ident.to_string()).join("::"));
+ }
+ }
+ for seg in path.segments.iter() {
+ self.search_path_arguments(&seg.arguments)?;
+ }
+ Ok(())
+ }
+
+ fn search_trait_item(&mut self, itm: &TraitItem) -> Result<(), DiscoveryErr> {
+ if let TraitItem::Method(itm) = itm {
+ if let Some(block) = &itm.default {
+ self.search_stmts(block.stmts.iter())?
+ }
+ }
+ Ok(())
+ }
+
+ fn search_stmts<'a>(
+ &mut self,
+ stmts: impl Iterator<Item = &'a Stmt>,
+ ) -> Result<(), DiscoveryErr> {
+ for stmt in stmts {
+ self.search_stmt(stmt)?
+ }
+ Ok(())
+ }
+
+ fn search_stmt(&mut self, stmt: &Stmt) -> Result<(), DiscoveryErr> {
+ match stmt {
+ Stmt::Local(lcl) => {
+ if let Some((_, expr)) = &lcl.init {
+ self.search_expr(expr)?
+ }
+ self.search_pat(&lcl.pat)
+ }
+ Stmt::Item(itm) => self.search_item(itm),
+ Stmt::Expr(exp) | Stmt::Semi(exp, _) => self.search_expr(exp),
+ }
+ }
+
+ fn search_expr(&mut self, expr: &Expr) -> Result<(), DiscoveryErr> {
+ match expr {
+ Expr::Path(exp) => {
+ self.search_path(&exp.path)?;
+ }
+ Expr::Macro(_) => {}
+ Expr::Array(array) => self.search_exprs(array.elems.iter())?,
+ Expr::Assign(ExprAssign { left, right, .. })
+ | Expr::AssignOp(ExprAssignOp { left, right, .. })
+ | Expr::Binary(ExprBinary { left, right, .. }) => {
+ self.search_expr(left)?;
+ self.search_expr(right)?;
+ }
+ Expr::Async(ass) => self.search_stmts(ass.block.stmts.iter())?,
+ Expr::Await(ExprAwait { base, .. }) | Expr::Field(ExprField { base, .. }) => {
+ self.search_expr(base)?
+ }
+ Expr::Block(blck) => self.search_stmts(blck.block.stmts.iter())?,
+ Expr::Box(ExprBox { expr, .. })
+ | Expr::Break(ExprBreak {
+ expr: Some(expr), ..
+ })
+ | Expr::Cast(ExprCast { expr, .. })
+ | Expr::Group(ExprGroup { expr, .. })
+ | Expr::Paren(ExprParen { expr, .. })
+ | Expr::Reference(ExprReference { expr, .. })
+ | Expr::Try(ExprTry { expr, .. })
+ | Expr::Type(ExprType { expr, .. })
+ | Expr::Unary(ExprUnary { expr, .. }) => self.search_expr(expr)?,
+ Expr::Call(exc) => {
+ self.search_expr(&exc.func)?;
+ self.search_exprs(exc.args.iter())?;
+ }
+ Expr::Closure(cls) => self.search_expr(&cls.body)?,
+ Expr::Continue(_)
+ | Expr::Lit(_)
+ | Expr::Break(ExprBreak { expr: None, .. })
+ | Expr::Verbatim(_) => {}
+ Expr::ForLoop(fl) => {
+ self.search_expr(&fl.expr)?;
+ self.search_stmts(fl.body.stmts.iter())?;
+ }
+ Expr::If(exif) => {
+ self.search_expr(&exif.cond)?;
+ self.search_stmts(exif.then_branch.stmts.iter())?;
+ if let Some((_, else_branch)) = &exif.else_branch {
+ self.search_expr(else_branch)?;
+ }
+ }
+ Expr::Index(exidx) => {
+ self.search_expr(&exidx.expr)?;
+ self.search_expr(&exidx.index)?;
+ }
+ Expr::Let(ExprLet { expr, pat, .. }) => {
+ self.search_expr(expr)?;
+ self.search_pat(pat)?;
+ }
+ Expr::Loop(exloo) => self.search_stmts(exloo.body.stmts.iter())?,
+ Expr::Match(exm) => {
+ self.search_expr(&exm.expr)?;
+ for a in &exm.arms {
+ self.search_expr(&a.body)?;
+ if let Some((_, guard)) = &a.guard {
+ self.search_expr(guard)?;
+ }
+ }
+ }
+ Expr::MethodCall(mtc) => {
+ self.search_expr(&mtc.receiver)?;
+ self.search_exprs(mtc.args.iter())?;
+ }
+ Expr::Range(exr) => {
+ self.search_option_expr(&exr.from)?;
+ self.search_option_expr(&exr.to)?;
+ }
+ Expr::Repeat(exr) => {
+ self.search_expr(&exr.expr)?;
+ self.search_expr(&exr.len)?;
+ }
+ Expr::Return(exret) => {
+ if let Some(expr) = &exret.expr {
+ self.search_expr(expr)?;
+ }
+ }
+ Expr::Struct(exst) => {
+ for f in &exst.fields {
+ self.search_expr(&f.expr)?;
+ }
+ self.search_option_expr(&exst.rest)?;
+ }
+ Expr::TryBlock(extb) => self.search_stmts(extb.block.stmts.iter())?,
+ Expr::Tuple(ext) => self.search_exprs(ext.elems.iter())?,
+ Expr::Unsafe(exs) => self.search_stmts(exs.block.stmts.iter())?,
+ Expr::While(exw) => {
+ self.search_expr(&exw.cond)?;
+ self.search_stmts(exw.body.stmts.iter())?;
+ }
+ Expr::Yield(exy) => self.search_option_expr(&exy.expr)?,
+ _ => {}
+ }
+ Ok(())
+ }
+
+ fn search_option_expr(&mut self, expr: &Option<Box<Expr>>) -> Result<(), DiscoveryErr> {
+ if let Some(expr) = &expr {
+ self.search_expr(expr)?;
+ }
+ Ok(())
+ }
+
+ fn search_exprs<'a>(
+ &mut self,
+ exprs: impl Iterator<Item = &'a Expr>,
+ ) -> Result<(), DiscoveryErr> {
+ for e in exprs {
+ self.search_expr(e)?;
+ }
+ Ok(())
+ }
+
+ fn search_impl_item(
+ &mut self,
+ impl_item: &ImplItem,
+ receiver: Option<&RustPath>,
+ ) -> Result<(), DiscoveryErr> {
+ if let ImplItem::Method(itm) = impl_item {
+ if Self::has_attr(&itm.attrs, EXTERN_RUST_FUN) {
+ if self.mod_path.is_some() {
+ return Err(DiscoveryErr::FoundExternRustFunWithinMod);
+ }
+ if let Some(receiver) = receiver {
+ // We have a method which we want to put into the cxx::bridge's
+ // "extern Rust" block.
+ let sig = add_receiver(&itm.sig, receiver.get_final_ident())?;
+ assert!(receiver.len() == 1);
+ self.discoveries.extern_rust_funs.push(RustFun {
+ path: self.deeper_path(&itm.sig.ident),
+ sig,
+ receiver: Some(receiver.get_final_ident().clone()),
+ });
+ self.discoveries.extern_rust_types.push(receiver.clone())
+ } else {
+ return Err(DiscoveryErr::FoundExternRustFunOnTypeWithoutClearReceiver);
+ }
+ }
+ for stmt in &itm.block.stmts {
+ self.search_stmt(stmt)?
+ }
+ }
+ Ok(())
+ }
+
+ fn search_pat(&mut self, pat: &Pat) -> Result<(), DiscoveryErr> {
+ match pat {
+ Pat::Box(PatBox { pat, .. }) | Pat::Reference(PatReference { pat, .. }) => {
+ self.search_pat(pat)
+ }
+ Pat::Ident(_) | Pat::Lit(_) | Pat::Macro(_) | Pat::Range(_) | Pat::Rest(_) => Ok(()),
+ Pat::Or(pator) => {
+ for case in &pator.cases {
+ self.search_pat(case)?;
+ }
+ Ok(())
+ }
+ Pat::Path(pp) => self.search_path(&pp.path),
+ Pat::Slice(PatSlice { elems, .. }) | Pat::Tuple(PatTuple { elems, .. }) => {
+ for case in elems {
+ self.search_pat(case)?;
+ }
+ Ok(())
+ }
+ Pat::Struct(ps) => {
+ self.search_path(&ps.path)?;
+ for f in &ps.fields {
+ self.search_pat(&f.pat)?;
+ }
+ Ok(())
+ }
+ Pat::TupleStruct(tps) => {
+ self.search_path(&tps.path)?;
+ for f in &tps.pat.elems {
+ self.search_pat(f)?;
+ }
+ Ok(())
+ }
+ Pat::Type(pt) => {
+ self.search_pat(&pt.pat)?;
+ self.search_type(&pt.ty)
+ }
+ _ => Ok(()),
+ }
+ }
+
+ fn search_type(&mut self, ty: &Type) -> Result<(), DiscoveryErr> {
+ match ty {
+ Type::Array(TypeArray { elem, .. })
+ | Type::Group(TypeGroup { elem, .. })
+ | Type::Paren(TypeParen { elem, .. })
+ | Type::Ptr(TypePtr { elem, .. })
+ | Type::Reference(TypeReference { elem, .. })
+ | Type::Slice(TypeSlice { elem, .. }) => self.search_type(elem)?,
+ Type::BareFn(tf) => {
+ for input in &tf.inputs {
+ self.search_type(&input.ty)?;
+ }
+ self.search_return_type(&tf.output)?;
+ }
+ Type::ImplTrait(tyit) => {
+ for b in &tyit.bounds {
+ if let syn::TypeParamBound::Trait(tyt) = b {
+ self.search_path(&tyt.path)?
+ }
+ }
+ }
+ Type::Infer(_) | Type::Macro(_) | Type::Never(_) => {}
+ Type::Path(typ) => self.search_path(&typ.path)?,
+ Type::TraitObject(tto) => self.search_type_param_bounds(&tto.bounds)?,
+ Type::Tuple(tt) => {
+ for e in &tt.elems {
+ self.search_type(e)?
+ }
+ }
+ _ => {}
+ }
+ Ok(())
+ }
+
+ fn search_type_param_bounds(
+ &mut self,
+ bounds: &Punctuated<TypeParamBound, syn::token::Add>,
+ ) -> Result<(), DiscoveryErr> {
+ for b in bounds {
+ if let syn::TypeParamBound::Trait(tpbt) = b {
+ self.search_path(&tpbt.path)?
+ }
+ }
+ Ok(())
+ }
+
+ fn search_return_type(&mut self, output: &ReturnType) -> Result<(), DiscoveryErr> {
+ if let ReturnType::Type(_, ty) = &output {
+ self.search_type(ty)
+ } else {
+ Ok(())
+ }
+ }
+
+ fn search_path_arguments(
+ &mut self,
+ arguments: &syn::PathArguments,
+ ) -> Result<(), DiscoveryErr> {
+ match arguments {
+ syn::PathArguments::None => {}
+ syn::PathArguments::AngleBracketed(paab) => {
+ for arg in &paab.args {
+ match arg {
+ syn::GenericArgument::Lifetime(_) => {}
+ syn::GenericArgument::Type(ty)
+ | syn::GenericArgument::Binding(Binding { ty, .. }) => {
+ self.search_type(ty)?
+ }
+ syn::GenericArgument::Constraint(c) => {
+ self.search_type_param_bounds(&c.bounds)?
+ }
+ syn::GenericArgument::Const(c) => self.search_expr(c)?,
+ }
+ }
+ }
+ syn::PathArguments::Parenthesized(pas) => {
+ self.search_return_type(&pas.output)?;
+ for t in &pas.inputs {
+ self.search_type(t)?;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ fn has_attr(attrs: &[Attribute], attr_name: &str) -> bool {
+ attrs.iter().any(|attr| {
+ attr.path
+ .segments
+ .last()
+ .map(|seg| seg.ident == attr_name)
+ .unwrap_or_default()
+ })
+ }
+}
+
+/// Take a method signature that may be `fn a(&self)`
+/// and turn it into `fn a(self: &A)` which is what we will
+/// need to specify to cxx.
+fn add_receiver(sig: &Signature, receiver: &Ident) -> Result<Signature, DiscoveryErr> {
+ let mut sig = sig.clone();
+ match sig.inputs.iter_mut().next() {
+ Some(first_arg) => match first_arg {
+ syn::FnArg::Receiver(Receiver {
+ reference: Some(_),
+ mutability: Some(_),
+ ..
+ }) => {
+ *first_arg = parse_quote! {
+ self: &mut #receiver
+ }
+ }
+ syn::FnArg::Receiver(Receiver {
+ reference: Some(_),
+ mutability: None,
+ ..
+ }) => {
+ *first_arg = parse_quote! {
+ self: &#receiver
+ }
+ }
+ syn::FnArg::Receiver(..) => return Err(DiscoveryErr::NonReferenceReceiver),
+ syn::FnArg::Typed(_) => {}
+ },
+ None => return Err(DiscoveryErr::NoParameterOnMethod),
+ }
+ Ok(sig)
+}
+
+#[cfg(test)]
+mod tests {
+ use quote::{quote, ToTokens};
+ use syn::{parse_quote, ImplItemMethod};
+
+ use crate::{ast_discoverer::add_receiver, types::make_ident};
+
+ use super::Discoveries;
+
+ fn assert_cpp_found(discoveries: &Discoveries) {
+ assert!(!discoveries.cpp_list.is_empty());
+ assert!(discoveries.cpp_list.iter().next().unwrap() == "xxx");
+ }
+
+ #[test]
+ fn test_mod_plain_call() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ mod foo {
+ fn bar() {
+ ffi::xxx()
+ }
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_plain_call() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar() {
+ ffi::xxx()
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_plain_call_with_semi() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar() {
+ ffi::xxx();
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_in_ns() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar() {
+ ffi::a::b::xxx();
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert!(!discoveries.cpp_list.is_empty());
+ assert!(discoveries.cpp_list.iter().next().unwrap() == "a::b::xxx");
+ }
+
+ #[test]
+ fn test_deep_nested_thingy() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar() {
+ a + 3 * foo(ffi::xxx());
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_ty_in_let() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar() {
+ let foo: ffi::xxx = bar();
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_ty_in_fn() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar(a: &mut ffi::xxx) {
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_ty_in_fn_up() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ fn bar(a: cxx::UniquePtr<ffi::xxx>) {
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert_cpp_found(&discoveries);
+ }
+
+ #[test]
+ fn test_extern_rust_fun() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ #[autocxx::extern_rust::extern_rust_function]
+ fn bar(a: cxx::UniquePtr<ffi::xxx>) {
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert!(discoveries.extern_rust_funs.get(0).unwrap().sig.ident == "bar");
+ }
+
+ #[test]
+ fn test_extern_rust_method() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ impl A {
+ #[autocxx::extern_rust::extern_rust_function]
+ fn bar(&self) {
+ }
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert!(discoveries.extern_rust_funs.get(0).unwrap().sig.ident == "bar");
+ }
+
+ #[test]
+ fn test_extern_rust_ty() {
+ let mut discoveries = Discoveries::default();
+ let itm = parse_quote! {
+ #[autocxx::extern_rust::extern_rust_type]
+ struct Bar {
+
+ }
+ };
+ discoveries.search_item(&itm, None).unwrap();
+ assert!(
+ discoveries
+ .extern_rust_types
+ .get(0)
+ .unwrap()
+ .get_final_ident()
+ == "Bar"
+ );
+ }
+
+ #[test]
+ fn test_add_receiver() {
+ let meth: ImplItemMethod = parse_quote! {
+ fn a(&self) {}
+ };
+ let a = make_ident("A");
+ assert_eq!(
+ add_receiver(&meth.sig, &a)
+ .unwrap()
+ .to_token_stream()
+ .to_string(),
+ quote! { fn a(self: &A) }.to_string()
+ );
+
+ let meth: ImplItemMethod = parse_quote! {
+ fn a(&mut self, b: u32) -> Foo {}
+ };
+ assert_eq!(
+ add_receiver(&meth.sig, &a)
+ .unwrap()
+ .to_token_stream()
+ .to_string(),
+ quote! { fn a(self: &mut A, b: u32) -> Foo }.to_string()
+ );
+
+ let meth: ImplItemMethod = parse_quote! {
+ fn a(self) {}
+ };
+ assert!(add_receiver(&meth.sig, &a).is_err());
+
+ let meth: ImplItemMethod = parse_quote! {
+ fn a() {}
+ };
+ assert!(add_receiver(&meth.sig, &a).is_err());
+ }
+}