Allow the context selector struct name to be specified

snafu-derive/src/lib.rs

@@ -47,6 +47,7 @@ struct VariantInfo {
 
 enum ContextSelectorKind {
     Context {
+        selector_name: syn::Ident,
         source_field: Option<SourceField>,
         user_fields: Vec<Field>,
     },
@@ -723,34 +724,48 @@ fn parse_snafu_enum(
             let (visibility, errs) = visibilities.finish();
             errors.extend(errs);
 
-            let (is_context, errs) = contexts.finish();
+            let (context_arg, errs) = contexts.finish();
             errors.extend(errs);
 
             let source_field = source.map(|(val, _tts)| val);
 
-            let selector_kind = if is_context.unwrap_or(true) {
-                ContextSelectorKind::Context {
-                    source_field,
-                    user_fields,
-                }
-            } else {
-                errors.extend(
-                    user_fields.into_iter().map(|Field { original, .. }| {
-                        syn::Error::new_spanned(
-                            original,
-                            "Context selectors without context must not have context fields",
-                        )
-                    })
-                );
-
-                let source_field = source_field.ok_or_else(|| {
-                        vec![syn::Error::new(
-                            variant_span,
-                            "Context selectors without context must have a source field",
-                        )]
-                    })?;
+            // if no context argument is specified, that's the same as specifying context(true)
+            let context_arg = context_arg.unwrap_or(ContextAttributeArgument::Enabled(true));
 
-                ContextSelectorKind::NoContext { source_field }
+            let selector_kind = match context_arg {
+                ContextAttributeArgument::Enabled(enabled) => {
+                    if enabled {
+                        ContextSelectorKind::Context {
+                            selector_name: name.clone(),
+                            source_field,
+                            user_fields,
+                        }
+                    } else {
+                        errors.extend(
+                            user_fields.into_iter().map(|Field { original, .. }| {
+                                syn::Error::new_spanned(
+                                    original,
+                                    "Context selectors without context must not have context fields",
+                                )
+                            })
+                        );
+
+                        let source_field = source_field.ok_or_else(|| {
+                                vec![syn::Error::new(
+                                    variant_span,
+                                    "Context selectors without context must have a source field",
+                                )]
+                            })?;
+                        ContextSelectorKind::NoContext { source_field }
+                    }
+                },
+                ContextAttributeArgument::CustomName(selector_name) => {
+                    ContextSelectorKind::Context {
+                        selector_name,
+                        source_field,
+                        user_fields,
+                    }
+                }
             };
 
             Ok(VariantInfo {
@@ -1013,10 +1028,15 @@ enum SnafuAttribute {
     Visibility(proc_macro2::TokenStream, UserInput),
     Source(proc_macro2::TokenStream, Vec<Source>),
     Backtrace(proc_macro2::TokenStream, bool),
-    Context(proc_macro2::TokenStream, bool),
+    Context(proc_macro2::TokenStream, ContextAttributeArgument),
     DocComment(proc_macro2::TokenStream, String),
 }
 
+enum ContextAttributeArgument {
+    Enabled(bool),
+    CustomName(syn::Ident),
+}
+
 impl syn::parse::Parse for SnafuAttribute {
     fn parse(input: syn::parse::ParseStream) -> SynResult<Self> {
         use syn::token::{Comma, Paren};
@@ -1060,10 +1080,26 @@ impl syn::parse::Parse for SnafuAttribute {
             }
         } else if name == "context" {
             if input.is_empty() {
-                Ok(SnafuAttribute::Context(input_tts, true))
+                Ok(SnafuAttribute::Context(
+                    input_tts,
+                    ContextAttributeArgument::Enabled(true),
+                ))
             } else {
-                let v: MyParens<LitBool> = input.parse()?;
-                Ok(SnafuAttribute::Context(input_tts, v.0.value))
+                let inside;
+                parenthesized!(inside in input);
+                if inside.peek(LitBool) {
+                    let v: LitBool = inside.parse()?;
+                    Ok(SnafuAttribute::Context(
+                        input_tts,
+                        ContextAttributeArgument::Enabled(v.value),
+                    ))
+                } else {
+                    let v: Ident = inside.parse()?;
+                    Ok(SnafuAttribute::Context(
+                        input_tts,
+                        ContextAttributeArgument::CustomName(v),
+                    ))
+                }
             }
         } else {
             Err(syn::Error::new(
@@ -1330,6 +1366,7 @@ impl<'a> quote::ToTokens for ContextSelector<'a> {
 
         match selector_kind {
             ContextSelectorKind::Context {
+                selector_name,
                 user_fields,
                 source_field,
             } => {
@@ -1344,7 +1381,7 @@ impl<'a> quote::ToTokens for ContextSelector<'a> {
                     .unwrap_or(&self.0.default_visibility);
 
                 let generics_list = quote! { <#(#original_lifetimes,)* #(#generic_names,)* #(#original_generic_types_without_defaults,)*> };
-                let selector_name = quote! { #variant_name<#(#generic_names,)*> };
+                let selector_type = quote! { #selector_name<#(#generic_names,)*> };
 
                 let names: Vec<_> = user_fields.iter().map(|f| f.name.clone()).collect();
                 let selector_doc = format!(
@@ -1357,15 +1394,15 @@ impl<'a> quote::ToTokens for ContextSelector<'a> {
                         quote! {
                             #[derive(Debug, Copy, Clone)]
                             #[doc = #selector_doc]
-                            #visibility struct #selector_name;
+                            #visibility struct #selector_type;
                         }
                     } else {
                         let visibilities = iter::repeat(visibility);
 
                         quote! {
                             #[derive(Debug, Copy, Clone)]
                             #[doc = #selector_doc]
-                            #visibility struct #selector_name {
+                            #visibility struct #selector_type {
                                 #(
                                     #[allow(missing_docs)]
                                     #visibilities #names: #generic_names
@@ -1387,7 +1424,7 @@ impl<'a> quote::ToTokens for ContextSelector<'a> {
 
                 let inherent_impl = if source_field.is_none() {
                     quote! {
-                    impl<#(#generic_names,)*> #selector_name
+                    impl<#(#generic_names,)*> #selector_type
                     {
                         #[doc = "Consume the selector and return a `Result` with the associated error"]
                         #visibility fn fail<#(#original_generics_without_defaults,)* __T>(self) -> core::result::Result<__T, #parameterized_enum_name>
@@ -1438,7 +1475,7 @@ impl<'a> quote::ToTokens for ContextSelector<'a> {
                     }
 
                     quote! {
-                        impl#generics_list snafu::IntoError<#parameterized_enum_name> for #selector_name
+                        impl#generics_list snafu::IntoError<#parameterized_enum_name> for #selector_type
                         where
                             #parameterized_enum_name: snafu::Error + snafu::ErrorCompat,
                             #(#where_clauses),*

src/guide/attributes.md

@@ -46,6 +46,38 @@ fn main() {
 }
 ```
 
+## Specifying the generated context selector type's name
+
+Sometimes, you may already have a struct with the same name as one of
+the variants of your error enum. You might also have 2 error enums
+that share a variant. In those cases, there may be naming collisions
+with the context selector type(s) generated by Snafu, which by default
+have the same name as the enum variant.
+
+To solve this, you can specify the name of the context selector that
+Snafu should generate, using `#[snafu(context(MySelectorName))]`.
+
+**Example**
+
+```rust
+# use snafu::{Snafu, ResultExt};
+#
+// some struct not related to the error
+struct Foo;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(context(FooContext))]
+    Foo {
+        source: std::io::Error
+    },
+}
+
+fn read_file() -> Result<Vec<u8>, Error> {
+    std::fs::read("/some/file/that/doesnt/exist").context(FooContext)
+}
+```
+
 ## Controlling context
 
 Sometimes, an underlying error can only occur in exactly one context

src/guide/the_macro.md

@@ -51,7 +51,8 @@ struct UserIdInvalid<I> { user_id: I }
 Notably:
 
 1. One context selector is created for each enum variant.
-1. The name of the selector is the same as the enum variant's name.
+1. The name of the selector is the same as the enum variant's name,
+   unless a different name is specified using the `context` attribute.
 1. The `source` and `backtrace` fields have been removed; the
    library will automatically handle this for you.
 1. Each remaining field's type has been replaced with a generic

tests/custom_selector_name.rs

@@ -0,0 +1,59 @@
+// This test is the same as basic.rs but with custom context selectors
+
+use snafu::{ResultExt, Snafu};
+use std::{
+    fs, io,
+    path::{Path, PathBuf},
+};
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(
+        context(OpenConfigContext),
+        display = r#"("Could not open config file at {}: {}", filename.display(), source)"#
+    )]
+    OpenConfig {
+        filename: PathBuf,
+        source: io::Error,
+    },
+    #[snafu(
+        context(SaveConfigContext),
+        display = r#"("Could not open config file at {}", source)"#
+    )]
+    SaveConfig { source: io::Error },
+    #[snafu(
+        context(InvalidUserContext),
+        display = r#"("User ID {} is invalid", user_id)"#
+    )]
+    InvalidUser { user_id: i32 },
+    #[snafu(context(MissingUserContext), display("No user available"))]
+    MissingUser,
+}
+
+type Result<T, E = Error> = std::result::Result<T, E>;
+
+const CONFIG_FILENAME: &str = "/tmp/config";
+
+fn example(root: impl AsRef<Path>, user_id: Option<i32>) -> Result<()> {
+    let root = root.as_ref();
+    let filename = &root.join(CONFIG_FILENAME);
+
+    let config = fs::read(filename).context(OpenConfigContext { filename })?;
+
+    let _user_id = match user_id {
+        None => MissingUserContext.fail()?,
+        Some(user_id) if user_id != 42 => InvalidUserContext { user_id }.fail()?,
+        Some(user_id) => user_id,
+    };
+
+    fs::write(filename, config).context(SaveConfigContext)?;
+
+    Ok(())
+}
+
+#[test]
+fn implements_error() {
+    fn check<T: std::error::Error>() {}
+    check::<Error>();
+    example("/some/directory/that/does/not/exist", None).unwrap_err();
+}