Merge pull request #158 from nikomatsakis/misc-improvements

Misc improvements

Author: nikomatsakis

book/src/formality_core/constructors.md

@@ -0,0 +1,8 @@
+# Constructors
+
+Unless you include `#[customize(constructors)]`, the `#[term]` macro automatically creates constructors as follows:
+
+- For a `struct`, defines a `new` method that takes an `impl Upcast<T>` for each of your fields.
+- For an `enum`, defines a method per variant that has fields (converted to snake-case).
+  - If the name of the variant is a Rust keyword like `Struct`, the method will be called `struct_`.
+  - We do not generate constructors for variants with no arguments.

crates/formality-check/src/where_clauses.rs

@@ -51,7 +51,7 @@ impl super::Check<'_> {
             WhereClauseData::TypeOfConst(ct, ty) => {
                 match ct.data() {
                     ConstData::Value(_, t) => {
-                        self.prove_goal(in_env, &assumptions, Relation::eq(ty, t))?
+                        self.prove_goal(in_env, &assumptions, Relation::equals(ty, t))?
                     }
                     ConstData::Variable(_) => {}
                 }

crates/formality-core/src/judgment.rs

@@ -182,18 +182,12 @@ macro_rules! push_rules {
         $crate::push_rules!(@match inputs() patterns() args $args);
     };
 
-    (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:ident, $($pats:tt)*) args $args:tt) => {
-        {
-            let $pat0 = Clone::clone($in0);
-            $crate::push_rules!(@match inputs($($inputs)*) patterns($($pats)*) args $args);
-        }
+    (@match inputs() patterns $patterns:tt args $args:tt) => {
+        compile_error!("more patterns in rule than arguments on fn")
     };
 
-    (@match inputs($in0:ident) patterns($pat0:ident) args $args:tt) => {
-        {
-            let $pat0 = Clone::clone($in0);
-            $crate::push_rules!(@match inputs() patterns() args $args);
-        }
+    (@match inputs $inputs:tt patterns() args $args:tt) => {
+        compile_error!("fewer patterns in rule than arguments on fn")
     };
 
     (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:ident : $ty0:ty, $($pats:tt)*) args $args:tt) => {
@@ -204,23 +198,37 @@ macro_rules! push_rules {
         }
     };
 
-    (@match inputs($in0:ident) patterns($pat0:ident : $ty0:ty) args $args:tt) => {
+    (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:ident : $ty0:ty) args $args:tt) => {
         {
             if let Some($pat0) = $crate::Downcast::downcast::<$ty0>($in0) {
-                $crate::push_rules!(@match inputs() patterns() args $args);
+                $crate::push_rules!(@match inputs($($inputs)*) patterns() args $args);
             }
         }
     };
 
+    (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:ident, $($pats:tt)*) args $args:tt) => {
+        {
+            let $pat0 = Clone::clone($in0);
+            $crate::push_rules!(@match inputs($($inputs)*) patterns($($pats)*) args $args);
+        }
+    };
+
+    (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:ident) args $args:tt) => {
+        {
+            let $pat0 = Clone::clone($in0);
+            $crate::push_rules!(@match inputs($($inputs)*) patterns() args $args);
+        }
+    };
+
     (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:pat, $($pats:tt)*) args $args:tt) => {
         if let Some($pat0) = $crate::Downcast::downcast(&$in0) {
             $crate::push_rules!(@match inputs($($inputs)*) patterns($($pats)*) args $args);
         }
     };
 
-    (@match inputs($in0:ident) patterns($pat0:pat) args $args:tt) => {
+    (@match inputs($in0:ident $($inputs:tt)*) patterns($pat0:pat) args $args:tt) => {
         if let Some($pat0) = $crate::Downcast::downcast(&$in0) {
-            $crate::push_rules!(@match inputs() patterns() args $args);
+            $crate::push_rules!(@match inputs($($inputs)*) patterns() args $args);
         }
     };
 
@@ -257,7 +265,9 @@ macro_rules! push_rules {
     };
 
     (@body $args:tt ($i:expr => $p:pat) $($m:tt)*) => {
-        for $p in $i {
+        // Explicitly calling `into_iter` silences some annoying lints
+        // in the case where `$i` is an `Option` or a `Result`
+        for $p in std::iter::IntoIterator::into_iter($i) {
             $crate::push_rules!(@body $args $($m)*);
         }
     };

crates/formality-core/src/parse/parser.rs

@@ -652,8 +652,9 @@ where
                 None => Err(ParseError::at(
                     text0,
                     format!(
-                        "wrong kind, expected a {}, found a {:?}",
+                        "wrong kind, expected a {}, found `{:?}`, which is a `{:?}`",
                         type_name,
+                        parameter,
                         parameter.kind()
                     ),
                 )),

crates/formality-macros/src/as_methods.rs

@@ -0,0 +1 @@
+

crates/formality-macros/src/cast.rs

@@ -1,5 +1,6 @@
-use proc_macro2::TokenStream;
-use quote::quote;
+use convert_case::{Case, Casing};
+use proc_macro2::{Ident, TokenStream};
+use quote::{quote, quote_spanned};
 use syn::Type;
 use synstructure::VariantInfo;
 
@@ -79,7 +80,7 @@ fn downcast_to_variant(s: &synstructure::Structure, v: &VariantInfo) -> TokenStr
         }
     });
 
-    s.gen_impl(quote! {
+    let mut ts = s.gen_impl(quote! {
         use formality_core::{DowncastTo};
 
         gen impl DowncastTo<(#(#binding_tys),*)> for @Self {
@@ -89,5 +90,44 @@ fn downcast_to_variant(s: &synstructure::Structure, v: &VariantInfo) -> TokenStr
                 }
             }
         }
-    })
+    });
+
+    if binding_tys.len() == 1 && matches!(s.ast().data, syn::Data::Enum(_)) {
+        let binding_ty = &binding_tys[0];
+        let type_name = &s.ast().ident;
+        let variant_name = &v.ast().ident;
+        let as_method_name = Ident::new(
+            &format!("as_{}", variant_name.to_string().to_case(Case::Snake)),
+            v.ast().ident.span(),
+        );
+        let (impl_generics, type_generics, where_clauses) = s.ast().generics.split_for_impl();
+
+        let match_arms = s.each_variant(|variant_info| {
+            if variant_info.ast().ident == v.ast().ident {
+                let bindings = variant_info.bindings();
+                let binding_idents: Vec<&syn::Ident> =
+                    bindings.iter().map(|b| &b.binding).collect();
+                quote! { Some((#(#binding_idents),*)) }
+            } else {
+                quote! { None }
+            }
+        });
+
+        let as_impl = quote_spanned! { v.ast().ident.span() =>
+            #[allow(dead_code)]
+            impl #impl_generics #type_name #type_generics
+            where #where_clauses
+            {
+                pub fn #as_method_name(&self) -> Option<& #binding_ty> {
+                    match self {
+                        #match_arms
+                    }
+                }
+            }
+        };
+
+        ts.extend(as_impl);
+    }
+
+    ts
 }

crates/formality-macros/src/constructors.rs

@@ -0,0 +1,83 @@
+use convert_case::{Case, Casing};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote_spanned;
+use synstructure::VariantInfo;
+
+const RUST_KEYWORDS: &[&str] = &[
+    "mut", "true", "false", "const", "static", "ref", "struct", "enum", "trait", "union", "fn",
+    "use", "return", "move", "let", "break", "loop", "continue", "await", "if", "for", "unsafe",
+];
+
+/// Create methods to build this type.
+///
+/// For a struct, we create a single `new` method that takes each field.
+///
+/// For an enum, we create methods named after each variant.
+pub(crate) fn constructor_methods(s: synstructure::Structure) -> TokenStream {
+    match s.ast().data {
+        syn::Data::Struct(_) => derive_new_for_struct(s),
+        syn::Data::Enum(_) => derive_new_for_variants(s),
+        syn::Data::Union(_) => return Default::default(),
+    }
+}
+
+fn derive_new_for_struct(s: synstructure::Structure<'_>) -> TokenStream {
+    derive_new_for_variant(
+        &s,
+        &s.variants()[0],
+        &Ident::new("new", s.ast().ident.span()),
+    )
+}
+
+fn derive_new_for_variants(s: synstructure::Structure<'_>) -> TokenStream {
+    s.variants()
+        .iter()
+        .map(|v| {
+            let mut fn_name = v.ast().ident.to_string().to_case(Case::Snake);
+            if RUST_KEYWORDS.iter().any(|&kw| kw == fn_name) {
+                fn_name.push('_');
+            }
+            let fn_name = Ident::new(&fn_name, v.ast().ident.span());
+            derive_new_for_variant(&s, v, &fn_name)
+        })
+        .collect()
+}
+
+fn derive_new_for_variant(
+    s: &synstructure::Structure<'_>,
+    v: &VariantInfo<'_>,
+    fn_name: &Ident,
+) -> TokenStream {
+    let type_name = &s.ast().ident;
+    let (impl_generics, type_generics, where_clauses) = s.ast().generics.split_for_impl();
+
+    // If there are no bindings, not worth it.
+    if v.bindings().is_empty() {
+        return TokenStream::default();
+    }
+
+    let binding_names = v.bindings().iter().map(|b| &b.binding).collect::<Vec<_>>();
+    let binding_types = v.bindings().iter().map(|b| &b.ast().ty).collect::<Vec<_>>();
+    let construct = v.construct(|_b, i| {
+        let name = binding_names[i];
+        quote_spanned!(
+            binding_names[i].span() =>
+            formality_core::Upcast::upcast(#name)
+        )
+    });
+
+    quote_spanned! { v.ast().ident.span() =>
+        #[allow(dead_code)]
+        impl #impl_generics #type_name #type_generics
+        where #where_clauses
+        {
+            pub fn #fn_name(
+                #(
+                    #binding_names: impl formality_core::Upcast<#binding_types>,
+                )*
+            ) -> Self {
+                #construct
+            }
+        }
+    }
+}

crates/formality-macros/src/custom.rs

@@ -4,6 +4,7 @@ use proc_macro2::TokenStream;
 pub(crate) struct Customize {
     pub parse: bool,
     pub debug: bool,
+    pub constructors: bool,
 }
 
 impl syn::parse::Parse for Customize {
@@ -28,6 +29,13 @@ impl syn::parse::Parse for Customize {
                     result.debug = true;
                 }
 
+                proc_macro2::TokenTree::Ident(ident) if ident == "constructors" => {
+                    if result.constructors {
+                        return Err(syn::Error::new(ident.span(), "already customizing debug"));
+                    }
+                    result.constructors = true;
+                }
+
                 _ => {
                     return Err(syn::Error::new(
                         token.span(),

crates/formality-macros/src/lib.rs

@@ -5,8 +5,10 @@ use spec::FormalitySpec;
 
 extern crate proc_macro;
 
+mod as_methods;
 mod attrs;
 mod cast;
+mod constructors;
 mod custom;
 mod debug;
 mod fixed_point;

crates/formality-macros/src/term.rs

@@ -5,6 +5,7 @@ use syn::DeriveInput;
 use crate::{
     attrs::{self, remove_formality_attributes},
     cast::{downcast_impls, upcast_impls},
+    constructors::constructor_methods,
     debug::derive_debug_with_spec,
     fold::derive_fold,
     parse::derive_parse_with_spec,
@@ -35,6 +36,11 @@ pub fn term(spec: Option<FormalitySpec>, mut input: DeriveInput) -> syn::Result<
     let term_impl = derive_term(synstructure::Structure::new(&input));
     let downcast_impls = downcast_impls(synstructure::Structure::new(&input));
     let upcast_impls = upcast_impls(synstructure::Structure::new(&input));
+    let constructors = if customize.constructors {
+        None
+    } else {
+        Some(constructor_methods(synstructure::Structure::new(&input)))
+    };
     remove_formality_attributes(&mut input);
 
     Ok(quote! {
@@ -48,6 +54,7 @@ pub fn term(spec: Option<FormalitySpec>, mut input: DeriveInput) -> syn::Result<
         #term_impl
         #(#downcast_impls)*
         #(#upcast_impls)*
+        #constructors
     })
 }