derive: allow where bounds in #[filter_fn]

Author: Kijewski

askama_derive/src/filter_fn.rs

@@ -12,7 +12,7 @@ use syn::spanned::Spanned;
 use syn::token::Mut;
 use syn::{
     Block, Expr, FnArg, GenericParam, ItemFn, Lifetime, Pat, PatType, ReturnType, Signature, Token,
-    Type, TypeParamBound, Visibility,
+    Type, TypeParamBound, Visibility, WhereClause,
 };
 
 use crate::{CompileError, HashMap, HashSet, parse_ts_or_compile_error};
@@ -130,6 +130,8 @@ struct FilterSignature {
     args_optional: Vec<FilterArgumentOptional>,
     /// Generic parameters in use by the required filter arguments
     args_required_generics: HashMap<Ident, FilterArgumentGeneric>,
+    /// The `where` clause of the source function
+    where_clause: Option<WhereClause>,
     /// Filter function result type
     result_ty: ReturnType,
 }
@@ -272,6 +274,7 @@ impl FilterSignature {
             args_required,
             args_optional,
             args_required_generics,
+            where_clause: sig.generics.where_clause.clone(),
             result_ty: sig.output.clone(),
         })
     }
@@ -677,6 +680,7 @@ impl FilterSignature {
         });
 
         let fn_token = &sig.fn_token;
+        let where_clause = self.where_clause.as_ref();
         let impl_generics = quote! { #(#required_generics: #required_generic_bounds,)* };
         let impl_struct_generics = quote! { #(#required_generics,)* #(#required_flags,)* };
         let lifetimes_fillers = self.lifetimes_fillers(|l| l.used_by_extra_args);
@@ -690,7 +694,7 @@ impl FilterSignature {
                     self,
                     #input_mutability #input_ident: #input_ty,
                     #env_ident: #env_ty
-                ) #result_ty {
+                ) #result_ty #where_clause {
                     // map filter variables with original name into scope
                     #( #required_args )*
                     #( #optional_args )*

testing/tests/filters.rs

@@ -717,3 +717,39 @@ fn filter_lifetimes() {
 
     assert_eq!(X.render().unwrap(), "a-b");
 }
+
+// Checks support for `where` clauses.
+#[test]
+fn issue_671() {
+    mod filters {
+        use std::convert::Infallible;
+
+        #[askama::filter_fn]
+        pub fn or_dash<'a, T>(
+            value: &'a Option<T>,
+            _: &'a dyn askama::Values,
+        ) -> askama::Result<&'a str, Infallible>
+        where
+            T: AsRef<str>,
+        {
+            Ok(match value {
+                Some(value) => value.as_ref(),
+                None => "--",
+            })
+        }
+    }
+
+    #[derive(Template)]
+    #[template(source = r#"{{ foo | or_dash }}"#, ext = "txt")]
+    struct Template {
+        foo: Option<String>,
+    }
+
+    let a = Template { foo: None };
+    assert_eq!(a.render().unwrap(), "--");
+
+    let a = Template {
+        foo: Some("ok".to_string()),
+    };
+    assert_eq!(a.render().unwrap(), "ok");
+}