Support other try types.

The `throws` macro now takes an optional `as TYPE` argument. If this is
present, instead of transforming the return type to `Result`, it transforms it
to `TYPE` parameterized by the return and error types.

The error type is optional as well: if no error type is present, the wrapper
type is parameterized only by the return type.

This allows you to write `#[throws(as Option)]` to make a throwing function
that returns an option.

It also supports other try types.

Syntactically, these two should both work and be equivalent:
`#[throws(io::Error as Poll<Result>)]`
`#[throws(as Poll<io::Result>)]`

However, these do not work because of the way the return type needs to be
wrapped in poll. More thought needs to go into how to support the Poll types.

Author: Without Boats

Cargo.toml

@@ -12,4 +12,7 @@ repository = "https://github.com/withoutboats/fehler"
 path = "./fehler-macros"
 version = "1.0.0-alpha.2"
 
+[features]
+nightly = []
+
 [workspace]

fehler-macros/Cargo.toml

@@ -16,5 +16,5 @@ quote = "1.0.0"
 proc-macro2 = "1.0.0"
 
 [dependencies.syn]
-features = ["default", "fold", "full"]
+features = ["default", "fold", "full", "parsing"]
 version = "1.0.0"

fehler-macros/src/args.rs

@@ -0,0 +1,106 @@
+// The Args type parses the arguments to the `#[throws]` macro.
+//
+// It is also responsible for transforming the return type by injecting
+// the return type and the error type into the wrapper type.
+
+use proc_macro2::Span;
+use syn::{GenericArgument, Path, PathArguments, ReturnType, Token, Type};
+use syn::parse::*;
+
+const WRAPPER_MUST_BE_PATH: &str = "Wrapper type must be a normal path type";
+
+pub struct Args {
+    error: Option<Type>,
+    wrapper: Option<Type>,
+}
+
+impl Args {
+    pub fn ret(&mut self, ret: ReturnType) -> ReturnType {
+        let (arrow, ret) = match ret {
+            ReturnType::Default         => (arrow(), unit()),
+            ReturnType::Type(arrow, ty) => (arrow, *ty),
+        };
+        ReturnType::Type(arrow, Box::new(self.inject_to_wrapper(ret)))
+
+    }
+
+    fn inject_to_wrapper(&mut self, ret: Type) -> Type {
+        if let Some(Type::Path(mut wrapper)) = self.wrapper.take() {
+            let types = if let Some(error) = self.error.take() {
+                vec![ret, error].into_iter().map(GenericArgument::Type)
+            } else {
+                vec![ret].into_iter().map(GenericArgument::Type)
+            };
+
+            match innermost_path_arguments(&mut wrapper.path) {
+                args @ &mut PathArguments::None    => {
+                    *args = PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
+                        colon2_token: None,
+                        lt_token: Token![<](Span::call_site()),
+                        args: types.collect(),
+                        gt_token: Token![>](Span::call_site()),
+                    });
+                }
+                PathArguments::AngleBracketed(args) => args.args.extend(types),
+                _   => panic!(WRAPPER_MUST_BE_PATH)
+            }
+
+            Type::Path(wrapper)
+        } else { panic!(WRAPPER_MUST_BE_PATH) }
+    }
+}
+
+impl Parse for Args {
+    fn parse(input: ParseStream) -> Result<Args> {
+        let error = match input.peek(Token![as]) {
+            true    => None,
+            false   => {
+                let error = input.parse()?;
+                Some(match error {
+                    Type::Infer(_)  => default_error(),
+                    _               => error,
+                })
+            }
+        };
+
+        let wrapper = Some(match input.parse::<Token![as]>().is_ok() {
+            true    => input.parse()?,
+            false   => result(),
+        });
+
+        Ok(Args { error, wrapper })
+    }
+}
+
+fn innermost_path_arguments(path: &mut Path) -> &mut PathArguments {
+    let arguments = &mut path.segments.last_mut().expect(WRAPPER_MUST_BE_PATH).arguments;
+    match arguments {
+        PathArguments::None                 => arguments,
+        PathArguments::AngleBracketed(args) => {
+            match args.args.last_mut() {
+                Some(GenericArgument::Type(Type::Path(inner)))  => {
+                    innermost_path_arguments(&mut inner.path)
+                }
+                // Bizarre cases like `#[throw(_ as MyTryType<'a>)]` just not supported currently
+                _   => panic!("Certain strange wrapper types not supported"),
+            }
+        }
+        _                                   => panic!(WRAPPER_MUST_BE_PATH)
+    }
+}
+
+fn arrow() -> syn::token::RArrow {
+    Token![->](Span::call_site())
+}
+
+fn unit() -> Type {
+    syn::parse_str("()").unwrap()
+}
+
+fn result() -> Type {
+    syn::parse_str("::core::result::Result").unwrap()
+}
+
+fn default_error() -> Type {
+    syn::parse_str("crate::Error").unwrap()
+}

fehler-macros/src/lib.rs

@@ -1,10 +1,15 @@
 extern crate proc_macro;
 
+mod args;
 mod throws;
 
 use proc_macro::*;
 
+use args::Args;
+use throws::Throws;
+
 #[proc_macro_attribute]
 pub fn throws(args: TokenStream, input: TokenStream) -> TokenStream {
-    crate::throws::entry(args, input)
+    let args = syn::parse_macro_input!(args as Args);
+    Throws::new(args).fold(input)
 }

fehler-macros/src/throws.rs

@@ -1,33 +1,38 @@
+// This module implements the Throws folder.
+//
+// The Throws folder actually visits the item being processed and performs two
+// processes:
+// - It ok wraps return expressions and inserts terminal Ok(())s.
+// - It delegates return type rewriting to the Args type.
+
 use proc_macro::*;
 use syn::fold::Fold;
 
-struct Throws {
-    ty: syn::Type,
+use crate::Args;
+
+pub struct Throws {
+    args: Args,
     outer_fn: bool,
 }
 
-pub fn entry(args: TokenStream, input: TokenStream) -> TokenStream {
-    let mut ty = syn::parse(args).unwrap_or_else(|_| {
-        panic!("argument to #[throws] attribute must be a type")
-    });
-
-    if let syn::Type::Infer(_) = ty {
-        ty = syn::parse2(quote::quote!(crate::Error)).unwrap();
+impl Throws {
+    pub fn new(args: Args) -> Throws {
+        Throws { args, outer_fn: true }
     }
 
-    let mut throws = Throws { ty, outer_fn: true };
-
-    if let Ok(item_fn) = syn::parse(input.clone()) {
-        let item_fn = throws.fold_item_fn(item_fn);
-        quote::quote!(#item_fn).into()
-    } else if let Ok(method) = syn::parse(input.clone()) {
-        let method = throws.fold_impl_item_method(method);
-        quote::quote!(#method).into()
-    } else if let Ok(method) = syn::parse(input.clone()) {
-        let method = throws.fold_trait_item_method(method);
-        quote::quote!(#method).into()
-    } else {
-        panic!("#[throws] attribute can only be applied to functions and methods")
+    pub fn fold(&mut self, input: TokenStream) -> TokenStream {
+        if let Ok(item_fn) = syn::parse(input.clone()) {
+            let item_fn = self.fold_item_fn(item_fn);
+            quote::quote!(#item_fn).into()
+        } else if let Ok(method) = syn::parse(input.clone()) {
+            let method = self.fold_impl_item_method(method);
+            quote::quote!(#method).into()
+        } else if let Ok(method) = syn::parse(input.clone()) {
+            let method = self.fold_trait_item_method(method);
+            quote::quote!(#method).into()
+        } else {
+            panic!("#[throws] attribute can only be applied to functions and methods")
+        }
     }
 }
 
@@ -91,22 +96,13 @@ impl Fold for Throws {
     }
 
     fn fold_return_type(&mut self, i: syn::ReturnType) -> syn::ReturnType {
-        let error = &self.ty;
-        match i {
-            syn::ReturnType::Default        => {
-                syn::parse2(quote::quote!(-> ::core::result::Result<(), #error>)).unwrap()
-            }
-            syn::ReturnType::Type(arrow, ty)    => {
-                let result = syn::parse2(quote::quote!(::core::result::Result<#ty, #error>)).unwrap();
-                syn::ReturnType::Type(arrow, result)
-            }
-        }
+        self.args.ret(i)
     }
 
     fn fold_expr_return(&mut self, i: syn::ExprReturn) -> syn::ExprReturn {
         let ok = match &i.expr {
-            Some(expr)  => syn::parse2(quote::quote!(::core::result::Result::Ok(#expr))).unwrap(),
-            None        => syn::parse2(quote::quote!(::core::result::Result::Ok(()))).unwrap(),
+            Some(expr)  => ok(expr),
+            None        => ok_unit(),
         };
         syn::ExprReturn { expr: Some(Box::new(ok)), ..i }
     }
@@ -121,13 +117,13 @@ fn modify_tail(is_unit_fn: bool, stmts: &mut Vec<syn::Stmt>) {
             let new = syn::parse2(quote::quote!(#e;)).unwrap();
             stmts.pop();
             stmts.push(new);
-            stmts.push(syn::Stmt::Expr(syn::parse2(quote::quote!(::core::result::Result::Ok(()))).unwrap()));
+            stmts.push(syn::Stmt::Expr(ok_unit()));
         }
         Some(syn::Stmt::Expr(e))    => {
-            *e = syn::parse2(quote::quote!(::core::result::Result::Ok(#e))).unwrap();
+            *e = ok(e);
         }
         _ if is_unit_fn             => {
-            stmts.push(syn::Stmt::Expr(syn::parse2(quote::quote!(::core::result::Result::Ok(()))).unwrap()));
+            stmts.push(syn::Stmt::Expr(ok_unit()));
         }
         _                           => { }
     }
@@ -144,3 +140,11 @@ fn is_unit_fn(i: &syn::ReturnType) -> bool {
         }
     }
 }
+
+fn ok(expr: &syn::Expr) -> syn::Expr {
+    syn::parse2(quote::quote!(<_ as ::fehler::__internal::_Succeed>::from_ok(#expr))).unwrap()
+}
+
+fn ok_unit() -> syn::Expr {
+    syn::parse2(quote::quote!(<_ as ::fehler::__internal::_Succeed>::from_ok(()))).unwrap()
+}

src/lib.rs

@@ -1,3 +1,5 @@
+#![no_std]
+#![cfg_attr(feature = "nightly", feature(try_trait))]
 #[doc(inline)]
 /// Annotations a function that "throws" a Result.
 ///
@@ -35,5 +37,106 @@ pub use fehler_macros::throws;
 /// This macro is equivalent to `Err($err)?`.
 #[macro_export]
 macro_rules! throw {
-    ($err:expr)   => (return ::core::result::Result::Err(::core::convert::From::from($err)))
+    ($err:expr)   => (return <_ as $crate::__internal::_Throw>::from_error((::core::convert::From::from($err))));
+    ()            => (return <_ as ::core::default::Default>::default());
+}
+
+#[doc(hidden)]
+pub mod __internal {
+    pub trait _Succeed {
+        type Ok;
+        fn from_ok(ok: Self::Ok) -> Self;
+    }
+
+    pub trait _Throw {
+        type Error;
+        fn from_error(error: Self::Error) -> Self;
+    }
+
+    #[cfg(not(feature = "nightly"))]
+    mod stable {
+        use core::task::Poll;
+
+        impl<T, E> super::_Succeed for Result<T, E> {
+            type Ok = T;
+            fn from_ok(ok: T) -> Self {
+                Ok(ok)
+            }
+        }
+
+        impl<T, E> super::_Throw for Result<T, E> {
+            type Error = E;
+            fn from_error(error: Self::Error) -> Self {
+                Err(error)
+            }
+        }
+
+        impl<T, E> super::_Succeed for Poll<Result<T, E>> {
+            type Ok = Poll<T>;
+
+            fn from_ok(ok: Self::Ok) -> Self {
+                match ok {
+                    Poll::Ready(ok) => Poll::Ready(Ok(ok)),
+                    Poll::Pending   => Poll::Pending,
+                }
+            }
+        }
+
+        impl<T, E> super::_Throw for Poll<Result<T, E>> {
+            type Error = E;
+
+            fn from_error(error: Self::Error) -> Self {
+                Poll::Ready(Err(error))
+            }
+        }
+
+        impl<T, E> super::_Succeed for Poll<Option<Result<T, E>>> {
+            type Ok = Poll<Option<T>>;
+
+            fn from_ok(ok: Self::Ok) -> Self {
+                match ok {
+                    Poll::Ready(Some(ok))   => Poll::Ready(Some(Ok(ok))),
+                    Poll::Ready(None)       => Poll::Ready(None),
+                    Poll::Pending           => Poll::Pending,
+                }
+            }
+        }
+
+        impl<T, E> super::_Throw for Poll<Option<Result<T, E>>> {
+            type Error = E;
+
+            fn from_error(error: Self::Error) -> Self {
+                Poll::Ready(Some(Err(error)))
+            }
+        }
+
+        impl<T> super::_Succeed for Option<T> {
+            type Ok = T;
+
+            fn from_ok(ok: Self::Ok) -> Self {
+                Some(ok)
+            }
+        }
+    }
+
+    #[cfg(feature = "nightly")]
+    mod nightly {
+        use core::ops::Try;
+
+        impl<T> super::_Succeed for T where T: Try {
+            type Ok = <T as Try>::Ok;
+
+            fn from_ok(ok: Self::Ok) -> Self {
+                <T as Try>::from_ok(ok)
+            }
+        }
+
+        impl<T> super::_Throw for T where T: Try {
+            type Error = <T as Try>::Error;
+
+            fn from_error(error: Self::Error) -> Self {
+                <T as Try>::from_error(error)
+            }
+        }
+    }
 }

tests/option.rs

@@ -0,0 +1,17 @@
+use fehler::*;
+
+#[throws(as Option)]
+fn foo(x: bool) -> i32 {
+    if x { throw!(); }
+    0
+}
+
+#[test]
+fn test_outcome_true() {
+    assert!(foo(true).is_none())
+}
+
+#[test]
+fn test_outcome_false() {
+    assert_eq!(Some(0), foo(false))
+}