Reworked the derive macro code

Each derive is now based on 2 things:
  - The item, which is the parsed DeriveInput
  - The context, which specifies how we want to render the item.  Do we
    want to generate metadata, which UniFfiTags should we implement
    traits on, etc.

Storing all the parsed DeriveInput parts in 1 type makes it easier to
change what/how we parse. We only need to update the struct not the
signatures of all the functions.

Adding the context will help make the UDL / proc-macro code more
consistent (mozilla#1865).  We can update the `udl_derive` method and have it
affect all UDL-based generation.  I also want to add a couple more
modes for remote types and remote UDL types.

Consolidated the `derive_*_for_udl` macros into a single `udl_derive` macro.
I think this is simpler and I also want to use the same basic structure
for the `remote_type` macro described in mozilla#2087.

Made EnumItem also parse error attributes.  I think this is simpler than
creating a separate EnumItem vs ErrorItem, at least for now.

Removed the `#[uniffi(non_exhaustive)]` attribute and parse the real
`#[non_exhaustive]` attribute instead.  This is easy to do now with the
new system and it will be simpler for the user when we implement remote types.

Author: bendk

uniffi_bindgen/src/scaffolding/templates/EnumTemplate.rs

@@ -2,11 +2,10 @@
 // Forward work to `uniffi_macros` This keeps macro-based and UDL-based generated code consistent.
 #}
 
-#[::uniffi::derive_enum_for_udl(
-    {%- if e.is_non_exhaustive() -%}
-    non_exhaustive,
-    {%- endif %}
-)]
+#[::uniffi::derive_enum_for_udl]
+{%- if e.is_non_exhaustive() %}
+#[non_exhaustive]
+{%- endif %}
 enum r#{{ e.name() }} {
     {%- for variant in e.variants() %}
     r#{{ variant.name() }} {

uniffi_macros/src/derive.rs

@@ -0,0 +1,103 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! General handling for the derive and udl_derive macros
+
+use crate::util::kw;
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::{quote, ToTokens};
+use syn::parse::{Parse, ParseStream};
+
+pub enum DeriveKind {
+    Record(kw::Record),
+    Enum(kw::Enum),
+    Error(kw::Error),
+    Object(kw::Object),
+}
+
+impl Parse for DeriveKind {
+    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
+        let lookahead = input.lookahead1();
+        if lookahead.peek(kw::Record) {
+            Ok(Self::Record(input.parse()?))
+        } else if lookahead.peek(kw::Enum) {
+            Ok(Self::Enum(input.parse()?))
+        } else if lookahead.peek(kw::Error) {
+            Ok(Self::Error(input.parse()?))
+        } else if lookahead.peek(kw::Object) {
+            Ok(Self::Object(input.parse()?))
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+pub struct DeriveContext {
+    /// Should we implement FFI traits for the local UniFfiTag only?
+    pub local_tag: bool,
+    /// Should we generate a metadata symbol?
+    pub generate_metadata: bool,
+}
+
+/// default() is used to construct a DeriveContext for a regular `derive` invocation
+impl Default for DeriveContext {
+    fn default() -> Self {
+        Self {
+            local_tag: false,
+            generate_metadata: true,
+        }
+    }
+}
+
+impl DeriveContext {
+    /// Construct the derive context for `udl_derive`
+    pub fn udl_derive() -> Self {
+        Self {
+            local_tag: true,
+            generate_metadata: false,
+        }
+    }
+
+    /// Generate the impl header for a FFI trait
+    ///
+    /// This will output something like `impl<UT> FfiConverter<UT> for #type`.  The caller is
+    /// responsible for providing the body if the impl block.
+    pub fn ffi_impl_header(&self, trait_name: &str, ident: &impl ToTokens) -> TokenStream {
+        let trait_name = Ident::new(trait_name, Span::call_site());
+        if self.local_tag {
+            quote! { impl ::uniffi::#trait_name<crate::UniFfiTag> for #ident }
+        } else {
+            quote! { impl<T> ::uniffi::#trait_name<T> for #ident }
+        }
+    }
+
+    /// Generate a call to `derive_ffi_traits!` that will derive all the FFI traits
+    pub fn derive_all_ffi_traits(&self, ty: &Ident) -> TokenStream {
+        if self.local_tag {
+            quote! { ::uniffi::derive_ffi_traits!(local #ty); }
+        } else {
+            quote! { ::uniffi::derive_ffi_traits!(blanket #ty); }
+        }
+    }
+
+    /// Generate a call to `derive_ffi_traits!` that will derive some of the FFI traits
+    pub fn derive_ffi_traits(&self, ty: impl ToTokens, trait_names: &[&str]) -> TokenStream {
+        let trait_idents = trait_names
+            .iter()
+            .map(|name| Ident::new(name, Span::call_site()));
+        if self.local_tag {
+            quote! {
+                #(
+                    ::uniffi::derive_ffi_traits!(impl #trait_idents<crate::UniFfiTag> for #ty);
+                )*
+            }
+        } else {
+            quote! {
+                #(
+                    ::uniffi::derive_ffi_traits!(impl<UT> #trait_idents<UT> for #ty);
+                )*
+            }
+        }
+    }
+}