Improve error handling.

proc-macro/Cargo.toml

@@ -18,6 +18,7 @@ proc-macro = true
 heck = "0.3.1"
 proc-macro2 = "1.0.18"
 proc-macro-crate = "0.1.4"
+proc-macro-error = "1.0.2"
 quote = "1.0.7"
 syn = "1.0.30"
 synstructure = "0.12.4"

proc-macro/src/lib.rs

@@ -24,32 +24,35 @@ mod test;
 mod utils;
 
 use proc_macro::TokenStream;
+use proc_macro_error::proc_macro_error;
 use synstructure::{
     decl_derive,
     Structure,
 };
 
 #[proc_macro_attribute]
+#[proc_macro_error]
 pub fn module(args: TokenStream, input: TokenStream) -> TokenStream {
     module::module(args.into(), input.into()).into()
 }
 
-decl_derive!([Call] => call);
+decl_derive!([Call] => #[proc_macro_error] call);
 fn call(s: Structure) -> TokenStream {
     call::call(s).into()
 }
 
-decl_derive!([Event] => event);
+decl_derive!([Event] => #[proc_macro_error] event);
 fn event(s: Structure) -> TokenStream {
     event::event(s).into()
 }
 
-decl_derive!([Store, attributes(store)] => store);
+decl_derive!([Store, attributes(store)] => #[proc_macro_error] store);
 fn store(s: Structure) -> TokenStream {
     store::store(s).into()
 }
 
 #[proc_macro]
+#[proc_macro_error]
 pub fn subxt_test(input: TokenStream) -> TokenStream {
     test::test(input.into()).into()
 }

proc-macro/src/module.rs

@@ -17,6 +17,7 @@
 use crate::utils;
 use heck::SnakeCase;
 use proc_macro2::TokenStream;
+use proc_macro_error::abort;
 use quote::{
     format_ident,
     quote,
@@ -49,7 +50,8 @@ fn ignore(attrs: &[syn::Attribute]) -> bool {
     for attr in attrs {
         if let Some(ident) = attr.path.get_ident() {
             if ident.to_string() == "module" {
-                let attrs: ModuleAttrs = syn::parse2(attr.tokens.clone()).unwrap();
+                let attrs: ModuleAttrs = syn::parse2(attr.tokens.clone())
+                    .map_err(|err| abort!("{}", err)).unwrap();
                 if !attrs.attrs.is_empty() {
                     return true
                 }
@@ -69,10 +71,12 @@ fn with_module_ident(module: &syn::Ident) -> syn::Ident {
 
 pub fn module(_args: TokenStream, tokens: TokenStream) -> TokenStream {
     let input: Result<syn::ItemTrait, _> = syn::parse2(tokens.clone());
-    if input.is_err() {
-        return tokens
-    }
-    let input = input.unwrap();
+    // handle #[module(ignore)] by just returning the tokens
+    let input = if input.is_err() {
+        return tokens;
+    } else {
+        input.unwrap()
+    };
 
     let subxt = utils::use_crate("substrate-subxt");
     let module = &input.ident;

proc-macro/src/store.rs

@@ -20,6 +20,7 @@ use heck::{
     SnakeCase,
 };
 use proc_macro2::TokenStream;
+use proc_macro_error::abort;
 use quote::{
     format_ident,
     quote,
@@ -50,7 +51,7 @@ impl Parse for StoreAttr {
 type StoreAttrs = utils::Attrs<StoreAttr>;
 
 fn parse_returns_attr(attr: &syn::Attribute) -> Option<(syn::Type, syn::Type, bool)> {
-    let attrs: StoreAttrs = syn::parse2(attr.tokens.clone()).unwrap();
+    let attrs: StoreAttrs = syn::parse2(attr.tokens.clone()).map_err(|err| abort!("{}", err)).unwrap();
     attrs.attrs.into_iter().next().map(|attr| {
         let StoreAttr::Returns(attr) = attr;
         let ty = attr.value;
@@ -81,7 +82,7 @@ pub fn store(s: Structure) -> TokenStream {
         .iter()
         .filter_map(|bi| bi.ast().attrs.iter().filter_map(parse_returns_attr).next())
         .next()
-        .expect("#[store(returns = ..)] needs to be specified.");
+        .unwrap_or_else(|| abort!(ident, "#[store(returns = ..)] needs to be specified."));
     let fetch = if uses_default {
         quote!(fetch_or_default)
     } else {
@@ -93,7 +94,9 @@ pub fn store(s: Structure) -> TokenStream {
             0 => "plain",
             1 => "map",
             2 => "double_map",
-            _ => panic!("invalid number of arguments"),
+            _ => {
+                abort!(ident, "Expected 0-2 fields but found {}", filtered_fields.len());
+            }
         }
     );
     let keys = filtered_fields

proc-macro/src/test.rs

@@ -16,6 +16,7 @@
 
 use crate::utils;
 use proc_macro2::TokenStream;
+use proc_macro_error::abort;
 use quote::{
     format_ident,
     quote,
@@ -161,6 +162,8 @@ impl From<ItemTest> for Test {
         let mut state = None;
         let mut prelude = None;
         let mut steps = vec![];
+
+        let span = test.brace.span;
         for test_item in test.items {
             match test_item {
                 TestItem::Name(item) => {
@@ -193,7 +196,7 @@ impl From<ItemTest> for Test {
         let runtime = runtime
             .unwrap_or_else(|| syn::parse2(quote!(#subxt::DefaultNodeRuntime)).unwrap());
         Self {
-            name: name.expect("No name specified"),
+            name: name.unwrap_or_else(|| abort!(span, "No name specified")),
             account: account.unwrap_or_else(|| format_ident!("Alice")),
             signature: signature.unwrap_or_else(|| {
                 syn::parse2(quote!(#subxt::sp_runtime::MultiSignature)).unwrap()
@@ -277,6 +280,7 @@ impl From<ItemStep> for Step {
         let mut event = vec![];
         let mut assert = None;
 
+        let span = step.brace.span;
         for step_item in step.items {
             match step_item {
                 StepItem::State(item) => {
@@ -297,7 +301,7 @@ impl From<ItemStep> for Step {
 
         Self {
             state,
-            call: call.expect("Step requires a call."),
+            call: call.unwrap_or_else(|| abort!(span, "Step requires a call.")),
             event_name,
             event,
             assert,
@@ -406,12 +410,12 @@ fn struct_name(expr: &syn::Expr) -> syn::Path {
     if let syn::Expr::Struct(syn::ExprStruct { path, .. }) = expr {
         return path.clone()
     } else {
-        panic!("not a struct");
+        abort!(expr, "Expected a struct");
     }
 }
 
 pub fn test(input: TokenStream) -> TokenStream {
-    let item_test: ItemTest = syn::parse2(input).unwrap();
+    let item_test: ItemTest = syn::parse2(input).map_err(|err| abort!("{}", err)).unwrap();
     Test::from(item_test).into_tokens()
 }