Prepare for nullary union variants

2 files changed, 54 insertions, 40 deletions

diff --git a/dhall_generator/src/derive.rs b/dhall_generator/src/derive.rs
index 740081a..852ffc8 100644
--- a/dhall_generator/src/derive.rs
+++ b/dhall_generator/src/derive.rs
@@ -71,35 +71,26 @@ fn derive_for_enum(
         .iter()
         .map(|v| {
             let name = dhall_core::Label::from(v.ident.to_string());
-            let ty = match &v.fields {
+            match &v.fields {
+                syn::Fields::Unit => Ok((name, None)),
                 syn::Fields::Unnamed(fields) if fields.unnamed.is_empty() => {
-                    Err(Error::new(
-                        v.span(),
-                        "Nullary variants are not supported",
-                    ))
+                    Ok((name, None))
                 }
-                syn::Fields::Unnamed(fields) if fields.unnamed.len() > 1 => {
-                    Err(Error::new(
-                        v.span(),
-                        "Variants with more than one field are not supported",
-                    ))
+                syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
+                    let ty = &fields.unnamed.iter().next().unwrap().ty;
+                    constraints.push(ty.clone());
+                    let ty = get_simple_static_type(ty);
+                    Ok((name, Some(quote!(#ty.into()))))
                 }
-                syn::Fields::Unnamed(fields) => {
-                    Ok(&fields.unnamed.iter().next().unwrap().ty)
-                }
-                syn::Fields::Named(_) => Err(Error::new(
+                syn::Fields::Unnamed(_) => Err(Error::new(
                     v.span(),
-                    "Named variants are not supported",
+                    "Variants with more than one field are not supported",
                 )),
-                syn::Fields::Unit => Err(Error::new(
+                syn::Fields::Named(_) => Err(Error::new(
                     v.span(),
-                    "Nullary variants are not supported",
+                    "Named variants are not supported",
                 )),
-            };
-            let ty = ty?;
-            constraints.push(ty.clone());
-            let ty = get_simple_static_type(ty);
-            Ok((name, quote!(#ty.into())))
+            }
         })
         .collect::<Result<_, Error>>()?;
 
diff --git a/dhall_generator/src/quote.rs b/dhall_generator/src/quote.rs
index 89107a9..c335666 100644
--- a/dhall_generator/src/quote.rs
+++ b/dhall_generator/src/quote.rs
@@ -31,23 +31,6 @@ pub fn quote_exprf<TS>(expr: ExprF<TS, Label, X, X>) -> TokenStream
 where
     TS: quote::ToTokens + std::fmt::Debug,
 {
-    let quote_map = |m: BTreeMap<Label, TS>| -> TokenStream {
-        let entries = m.into_iter().map(|(k, v)| {
-            let k = quote_label(&k);
-            quote!(m.insert(#k, #v);)
-        });
-        quote! { {
-            use std::collections::BTreeMap;
-            let mut m = BTreeMap::new();
-            #( #entries )*
-            m
-        } }
-    };
-
-    let quote_vec = |e: Vec<TS>| -> TokenStream {
-        quote! { vec![ #(#e),* ] }
-    };
-
     use dhall_core::ExprF::*;
     match expr {
         Var(_) => unreachable!(),
@@ -106,7 +89,7 @@ where
             quote! { dhall_core::ExprF::RecordLit(#m) }
         }
         UnionType(m) => {
-            let m = quote_map(m);
+            let m = quote_opt_map(m);
             quote! { dhall_core::ExprF::UnionType(#m) }
         }
         e => unimplemented!("{:?}", e),
@@ -206,3 +189,43 @@ fn quote_label(l: &Label) -> TokenStream {
 fn rc(x: TokenStream) -> TokenStream {
     quote! { dhall_core::rc(#x) }
 }
+
+fn quote_opt<TS>(x: Option<TS>) -> TokenStream
+where
+    TS: quote::ToTokens + std::fmt::Debug,
+{
+    match x {
+        Some(x) => quote!(Some(#x)),
+        None => quote!(None),
+    }
+}
+
+fn quote_vec<TS>(e: Vec<TS>) -> TokenStream
+where
+    TS: quote::ToTokens + std::fmt::Debug,
+{
+    quote! { vec![ #(#e),* ] }
+}
+
+fn quote_map<TS>(m: BTreeMap<Label, TS>) -> TokenStream
+where
+    TS: quote::ToTokens + std::fmt::Debug,
+{
+    let entries = m.into_iter().map(|(k, v)| {
+        let k = quote_label(&k);
+        quote!(m.insert(#k, #v);)
+    });
+    quote! { {
+        use std::collections::BTreeMap;
+        let mut m = BTreeMap::new();
+        #( #entries )*
+        m
+    } }
+}
+
+fn quote_opt_map<TS>(m: BTreeMap<Label, Option<TS>>) -> TokenStream
+where
+    TS: quote::ToTokens + std::fmt::Debug,
+{
+    quote_map(m.into_iter().map(|(k, v)| (k, quote_opt(v))).collect())
+}