1 files changed, 28 insertions, 45 deletions

diff --git a/third_party/rust/uniffi_macros/src/lib.rs b/third_party/rust/uniffi_macros/src/lib.rs
index 4cffddfa0e..929400c885 100644
--- a/third_party/rust/uniffi_macros/src/lib.rs
+++ b/third_party/rust/uniffi_macros/src/lib.rs
@@ -5,10 +5,8 @@
 #![warn(rust_2018_idioms, unused_qualifications)]
 
 //! Macros for `uniffi`.
-//!
-//! Currently this is just for easily generating integration tests, but maybe
-//! we'll put some other code-annotation helper macros in here at some point.
 
+#[cfg(feature = "trybuild")]
 use camino::Utf8Path;
 use proc_macro::TokenStream;
 use quote::quote;
@@ -18,6 +16,7 @@ use syn::{
 };
 
 mod custom;
+mod default;
 mod enum_;
 mod error;
 mod export;
@@ -33,20 +32,6 @@ use self::{
     record::expand_record,
 };
 
-struct IdentPair {
-    lhs: Ident,
-    rhs: Ident,
-}
-
-impl Parse for IdentPair {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let lhs = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let rhs = input.parse()?;
-        Ok(Self { lhs, rhs })
-    }
-}
-
 struct CustomTypeInfo {
     ident: Ident,
     builtin: Path,
@@ -107,9 +92,8 @@ fn do_export(attr_args: TokenStream, input: TokenStream, udl_mode: bool) -> Toke
     let copied_input = (!udl_mode).then(|| proc_macro2::TokenStream::from(input.clone()));
 
     let gen_output = || {
-        let args = syn::parse(attr_args)?;
         let item = syn::parse(input)?;
-        expand_export(item, args, udl_mode)
+        expand_export(item, attr_args, udl_mode)
     };
     let output = gen_output().unwrap_or_else(syn::Error::into_compile_error);
 
@@ -129,7 +113,7 @@ pub fn derive_record(input: TokenStream) -> TokenStream {
 
 #[proc_macro_derive(Enum)]
 pub fn derive_enum(input: TokenStream) -> TokenStream {
-    expand_enum(parse_macro_input!(input), false)
+    expand_enum(parse_macro_input!(input), None, false)
         .unwrap_or_else(syn::Error::into_compile_error)
         .into()
 }
@@ -225,10 +209,14 @@ pub fn derive_record_for_udl(_attrs: TokenStream, input: TokenStream) -> TokenSt
 
 #[doc(hidden)]
 #[proc_macro_attribute]
-pub fn derive_enum_for_udl(_attrs: TokenStream, input: TokenStream) -> TokenStream {
-    expand_enum(syn::parse_macro_input!(input), true)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
+pub fn derive_enum_for_udl(attrs: TokenStream, input: TokenStream) -> TokenStream {
+    expand_enum(
+        syn::parse_macro_input!(input),
+        Some(syn::parse_macro_input!(attrs)),
+        true,
+    )
+    .unwrap_or_else(syn::Error::into_compile_error)
+    .into()
 }
 
 #[doc(hidden)]
@@ -257,22 +245,6 @@ pub fn export_for_udl(attrs: TokenStream, input: TokenStream) -> TokenStream {
     do_export(attrs, input, true)
 }
 
-/// Generate various support elements, including the FfiConverter implementation,
-/// for a trait interface for the scaffolding code
-#[doc(hidden)]
-#[proc_macro]
-pub fn expand_trait_interface_support(tokens: TokenStream) -> TokenStream {
-    export::ffi_converter_trait_impl(&syn::parse_macro_input!(tokens), true).into()
-}
-
-/// Generate the FfiConverter implementation for an trait interface for the scaffolding code
-#[doc(hidden)]
-#[proc_macro]
-pub fn scaffolding_ffi_converter_callback_interface(tokens: TokenStream) -> TokenStream {
-    let input: IdentPair = syn::parse_macro_input!(tokens);
-    export::ffi_converter_callback_interface_impl(&input.lhs, &input.rhs, true).into()
-}
-
 /// A helper macro to include generated component scaffolding.
 ///
 /// This is a simple convenience macro to include the UniFFI component
@@ -373,6 +345,7 @@ pub fn use_udl_object(tokens: TokenStream) -> TokenStream {
 /// uniffi_macros::generate_and_include_scaffolding!("path/to/my/interface.udl");
 /// ```
 #[proc_macro]
+#[cfg(feature = "trybuild")]
 pub fn generate_and_include_scaffolding(udl_file: TokenStream) -> TokenStream {
     let udl_file = syn::parse_macro_input!(udl_file as LitStr);
     let udl_file_string = udl_file.value();
@@ -396,15 +369,25 @@ pub fn generate_and_include_scaffolding(udl_file: TokenStream) -> TokenStream {
     }.into()
 }
 
-/// A dummy macro that does nothing.
+/// An attribute for constructors.
+///
+/// Constructors are in `impl` blocks which have a `#[uniffi::export]` attribute,
 ///
 /// This exists so `#[uniffi::export]` can emit its input verbatim without
-/// causing unexpected errors, plus some extra code in case everything is okay.
+/// causing unexpected errors in the entire exported block.
+/// This happens very often when the proc-macro is run on an incomplete
+/// input by rust-analyzer while the developer is typing.
 ///
-/// It is important for `#[uniffi::export]` to not raise unexpected errors if it
-/// fails to parse the input as this happens very often when the proc-macro is
-/// run on an incomplete input by rust-analyzer while the developer is typing.
+/// So much better to do nothing here then let the impl block find the attribute.
 #[proc_macro_attribute]
 pub fn constructor(_attrs: TokenStream, input: TokenStream) -> TokenStream {
     input
 }
+
+/// An attribute for methods.
+///
+/// Everything above applies here too.
+#[proc_macro_attribute]
+pub fn method(_attrs: TokenStream, input: TokenStream) -> TokenStream {
+    input
+}