Add enum config and the "output" option to the dart_enum macro

Author: jerel

membrane/src/lib.rs

@@ -226,18 +226,26 @@ impl std::fmt::Debug for DeferredTrace {
   }
 }
 
+#[doc(hidden)]
+#[derive(Debug, Clone)]
+pub struct Enum {
+  pub name: &'static str,
+  pub output: Option<&'static str>,
+  pub namespace: &'static str,
+}
+
 #[doc(hidden)]
 #[derive(Clone)]
 pub struct DeferredEnumTrace {
-  pub name: &'static str,
+  pub enum_data: Enum,
   pub namespace: &'static str,
   pub trace: fn(tracer: &mut serde_reflection::Tracer),
 }
 
 impl std::fmt::Debug for DeferredEnumTrace {
   fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
     f.debug_struct("DeferredEnumTrace")
-      .field("name", &self.name)
+      .field("enum_data", &self.enum_data)
       .field("namespace", &self.namespace)
       .finish()
   }
@@ -264,8 +272,10 @@ pub struct Membrane {
   namespaces: Vec<&'static str>,
   namespaced_registry: HashMap<&'static str, serde_reflection::Result<Registry>>,
   namespaced_fn_registry: HashMap<&'static str, Vec<Function>>,
+  namespaced_enum_registry: HashMap<&'static str, Vec<Enum>>,
   generated: bool,
   c_style_enums: bool,
+  sealed_enums: bool,
   timeout: Option<i32>,
   borrows: Borrows,
   _inputs: Vec<libloading::Library>,
@@ -346,7 +356,7 @@ impl<'a> Membrane {
       );
     }
 
-    enums.sort_by_cached_key(|e| &e.name);
+    enums.sort_by_cached_key(|e| &e.enum_data.name);
 
     functions.sort_by_cached_key(|f| {
       format!(
@@ -367,6 +377,7 @@ impl<'a> Membrane {
     let mut namespaced_registry = HashMap::new();
     let mut namespaced_samples = HashMap::new();
     let mut namespaced_fn_registry = HashMap::new();
+    let mut namespaced_enum_registry = HashMap::new();
     let mut borrows: Borrows = HashMap::new();
 
     // collect all the metadata about functions (without tracing them yet)
@@ -382,6 +393,14 @@ impl<'a> Membrane {
       Self::create_borrows(&namespaced_fn_registry, namespace, &mut borrows);
     });
 
+    // collect all the metadata about functions (without tracing them yet)
+    enums.iter().for_each(|item| {
+      namespaced_enum_registry
+        .entry(item.namespace)
+        .or_insert_with(Vec::new)
+        .push(item.enum_data.clone());
+    });
+
     // trace all the enums at least once
     enums.iter().for_each(|item| {
       // trace the enum into the borrowing namespace's registry
@@ -390,7 +409,7 @@ impl<'a> Membrane {
         .into_iter()
         .for_each(|(for_namespace, from_namespaces)| {
           if let Some((types, _location)) = from_namespaces.get(item.namespace) {
-            if types.contains(item.name) {
+            if types.contains(item.enum_data.name) {
               let tracer = namespaced_registry
                 .entry(for_namespace)
                 .or_insert_with(|| Tracer::new(TracerConfig::default()));
@@ -449,9 +468,11 @@ impl<'a> Membrane {
         .map(|(key, val)| (key, val.registry()))
         .collect(),
       namespaced_fn_registry,
+      namespaced_enum_registry,
       namespaces,
       generated: false,
       c_style_enums: true,
+      sealed_enums: true,
       timeout: None,
       borrows,
       _inputs: input_libs,
@@ -544,7 +565,24 @@ impl<'a> Membrane {
       debug!("Generating lib/src/ code for namespace {}", namespace);
       let config = serde_generate::CodeGeneratorConfig::new(namespace.to_string())
         .with_encodings(vec![serde_generate::Encoding::Bincode])
-        .with_c_style_enums(self.c_style_enums);
+        .with_c_style_enums(self.c_style_enums)
+        .with_sealed_enums(self.sealed_enums)
+        .with_enum_type_overrides(
+          self
+            .namespaced_enum_registry
+            .get(namespace)
+            .into_iter()
+            .flat_map(|enums| {
+              enums.iter().filter_map(|x| {
+                if x.output.is_some() {
+                  Some((x.name, x.output.unwrap()))
+                } else {
+                  None
+                }
+              })
+            })
+            .collect::<HashMap<&'static str, &'static str>>(),
+        );
 
       let registry = match self.namespaced_registry.get(namespace).unwrap() {
         Ok(reg) => reg,
@@ -604,6 +642,16 @@ impl<'a> Membrane {
     self
   }
 
+  ///
+  /// When set to `true` (the default) we generate sealed classes for complex enums
+  /// instead of abstract classes. When set to `false`
+  /// abstract classes are generated.
+  pub fn with_sealed_enums(&mut self, val: bool) -> &mut Self {
+    return_if_error!(self);
+    self.sealed_enums = val;
+    self
+  }
+
   ///
   /// Configures the global timeout for non-stream receive ports.
   /// Streams do not use the global timeout as it is unusual to want a stream to timeout

membrane_macro/src/lib.rs

@@ -5,14 +5,16 @@ use membrane_types::heck::ToLowerCamelCase;
 use membrane_types::rust::{flatten_types, RustArgs, RustExternParams, RustTransforms};
 use membrane_types::syn::Attribute;
 use membrane_types::{proc_macro2, quote, syn, Input, OutputStyle};
-use options::{extract_function_options, FunctionOptions};
+use options::{extract_enum_options, extract_function_options, FunctionOptions};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::quote;
 use std::convert::TryFrom;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::{parse_macro_input, punctuated::Punctuated, Block, Ident, MetaNameValue, Token, Type};
 
+use crate::options::EnumOptions;
+
 mod options;
 mod parsers;
 mod utils;
@@ -436,16 +438,16 @@ impl Parse for ReprDartEnum {
 ///
 /// Valid options:
 ///   * `namespace`, used to select the Dart implementation code directory.
+///   * `output`, used to override global enum config of `enum`, `sealed`, or `abstract`.
 #[proc_macro_attribute]
 pub fn dart_enum(attrs: TokenStream, input: TokenStream) -> TokenStream {
-  let FunctionOptions {
-    namespace, borrow, ..
-  } = match extract_function_options(
+  let EnumOptions {
+    namespace, output, ..
+  } = match extract_enum_options(
     parse_macro_input!(attrs with Punctuated::<MetaNameValue, Token![,]>::parse_terminated)
       .into_iter()
       .collect(),
-    FunctionOptions::default(),
-    false,
+    EnumOptions::default(),
   ) {
     Ok(options) => options,
     Err(err) => {
@@ -458,24 +460,22 @@ pub fn dart_enum(attrs: TokenStream, input: TokenStream) -> TokenStream {
   let mut variants = TokenStream::new();
   variants.extend(input.clone());
 
-  if !borrow.is_empty() {
-    variants.extend::<TokenStream>(
-      syn::Error::new(
-        Span::call_site(),
-        "`borrow` is not a valid option for #[dart_enum]",
-      )
-      .to_compile_error()
-      .into(),
-    );
-  }
-
   let ReprDartEnum { name } = parse_macro_input!(input as ReprDartEnum);
   let enum_name = name.to_string();
+  let output = if let Some(val) = output {
+    quote! { Some(#val) }
+  } else {
+    quote! { None }
+  };
 
   let _deferred_trace = quote! {
       ::membrane::inventory::submit! {
           ::membrane::DeferredEnumTrace {
-              name: #enum_name,
+              enum_data: ::membrane::Enum {
+                name: #enum_name,
+                output: #output,
+                namespace: #namespace
+              },
               namespace: #namespace,
               trace: |
                 tracer: &mut ::membrane::serde_reflection::Tracer

membrane_macro/src/options.rs

@@ -10,6 +10,12 @@ pub(crate) struct FunctionOptions {
   pub borrow: Vec<String>,
 }
 
+#[derive(Debug, Default)]
+pub(crate) struct EnumOptions {
+  pub namespace: String,
+  pub output: Option<String>,
+}
+
 pub(crate) fn extract_function_options(
   mut input: Vec<MetaNameValue>,
   mut options: FunctionOptions,
@@ -127,6 +133,56 @@ pub(crate) fn extract_function_options(
   extract_function_options(input, options, sync)
 }
 
+pub(crate) fn extract_enum_options(
+  mut input: Vec<MetaNameValue>,
+  mut options: EnumOptions,
+) -> Result<EnumOptions, String> {
+  let option = match input.pop() {
+    Some(syn::MetaNameValue { path, value, .. }) => {
+      let ident = path.get_ident().unwrap().clone();
+      Some((ident, value))
+    }
+    _ => None,
+  };
+
+  let options = match option {
+    Some((
+      ident,
+      Lit(ExprLit {
+        lit: syn::Lit::Str(val),
+        ..
+      }),
+    )) if ident == "namespace" => {
+      options.namespace = val.value();
+      options
+    }
+    Some((
+      ident,
+      Lit(ExprLit {
+        lit: syn::Lit::Str(val),
+        ..
+      }),
+    )) if ident == "output" => {
+      options.output = Some(val.value());
+      options
+    }
+    Some(_) => {
+      return Err(
+        r#"only `namespace=""`, and `output="enum|sealed|abstract"` are valid options"#.to_string(),
+      );
+    }
+    None => {
+      // we've iterated over all options and didn't find a namespace (required)
+      if options.namespace.is_empty() {
+        return Err(format!("#[dart_enum] expects a `namespace` attribute"));
+      }
+
+      return Ok(options);
+    }
+  };
+
+  extract_enum_options(input, options)
+}
 fn invalid_option(macr: &str, opt: &str) -> Result<FunctionOptions, String> {
   Err(format!(
     "`{opt}` is not a valid option for `{m}`",