Fix issues #4 and #5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sealed"
-version = "0.1.3"
+version = "0.2.0-rc2"
 authors = ["José Duarte <jmg.duarte@campus.fct.unl.pt>"]
 license = "MIT OR Apache-2.0"
 description = "Macro for sealing traits and structures"
@@ -10,14 +10,10 @@ categories = ["development-tools", "rust-patterns"]
 keywords = ["proc_macro", "sealed", "future-proofing"]
 readme = "README.md"
 edition = "2018"
-exclude = [
-    "images/*"
-]
+exclude = ["images/*"]
 
 [workspace]
-members = [
-    "demo"
-]
+members = ["demo"]
 
 [lib]
 proc-macro = true
@@ -29,4 +25,5 @@ syn = { version = "1.0", features = ["extra-traits"] }
 [dependencies]
 syn = { version = "1.0", features = ["full"] }
 quote = "1.0"
-proc-macro2 = "1.0"
+proc-macro2 = "1.0"
+heck = "0.3"

README.md

@@ -10,30 +10,30 @@ as described in the Rust API Guidelines [[1](https://rust-lang.github.io/api-gui
 
 ```toml
 [dependencies]
-sealed = "0.1"
+sealed = "0.2.0-rc2"
 ```
 
 ## Example
 
 In the following code structs `A` and `B` implement the sealed trait `T`,
 the `C` struct, which is not sealed, will error during compilation.
 
-You can see a demo in [`demo/`](demo/).
+Examples are available in [`examples/`](examples/), you can also see a demo in [`demo/`](demo/).
 
 ```rust
 use sealed::sealed;
 
 #[sealed]
 trait T {}
 
-#[sealed]
 pub struct A;
 
+#[sealed]
 impl T for A {}
 
-#[sealed]
 pub struct B;
 
+#[sealed]
 impl T for B {}
 
 pub struct C;
@@ -47,23 +47,57 @@ fn main() {
 
 ## Details
 
-The macro generates a `private` module when attached to a `trait`
-(this raises the limitation that the `#[sealed]` macro can only be added to a single trait per module),
-when attached to a `struct` the generated code simply implements the sealed trait for the respective structure.
+The `#[sealed]` attribute can be attached to either a `trait` or an `impl`.
+It supports:
+- Several traits per module
+- Generic parameters
+- Foreign types
+- Blanket `impl`s
 
 
-### Expansion
+## Expansion
+
+### Input
 
 ```rust
-// #[sealed]
-// trait T {}
-trait T: private::Sealed {}
-mod private {
-    trait Sealed {}
+use sealed::sealed;
+
+#[sealed]
+pub trait T {}
+
+pub struct A;
+pub struct B(i32);
+
+#[sealed]
+impl T for A {}
+#[sealed]
+impl T for B {}
+
+fn main() {
+    return;
+}
+```
+
+### Expanded
+
+```rust
+use sealed::sealed;
+
+pub(crate) mod __seal_for_t {
+    pub trait Sealed {}
 }
+pub trait T: __seal_for_t::Sealed {}
 
-// #[sealed]
-// pub struct A;
 pub struct A;
-impl private::Sealed for A {}
+pub struct B(i32);
+
+impl __seal_for_t::Sealed for A {}
+impl T for A {}
+
+impl __seal_for_t::Sealed for B {}
+impl T for B {}
+
+fn main() {
+    return;
+}
 ```

demo/src/main.rs

@@ -12,16 +12,16 @@ where
     state: PhantomData<State>,
 }
 
-#[sealed]
 pub struct Idle;
+#[sealed]
 impl DroneState for Idle {}
 
-#[sealed]
 pub struct Hovering;
+#[sealed]
 impl DroneState for Hovering {}
 
-#[sealed]
 pub struct Flying;
+#[sealed]
 impl DroneState for Flying {}
 
 impl Drone<Idle> {

examples/generics.rs

@@ -0,0 +1,15 @@
+// Test provided in #4
+// https://github.com/jmg-duarte/sealed-rs/issues/4
+
+use sealed::sealed;
+
+#[sealed]
+pub trait Set<V> {}
+
+#[sealed]
+impl<T> Set<Option<T>> for T {}
+
+#[sealed]
+impl<T> Set<Option<T>> for Option<T> {}
+
+fn main() {}

examples/nesting.rs

@@ -0,0 +1,27 @@
+use sealed::sealed;
+
+mod lets {
+    pub mod attempt {
+        pub mod some {
+            pub mod nesting {
+                use sealed::sealed;
+                #[sealed]
+                pub trait LongerSnakeCaseType {}
+            }
+        }
+    }
+}
+
+pub struct A;
+
+pub struct B(i32);
+
+#[sealed]
+impl lets::attempt::some::nesting::LongerSnakeCaseType for A {}
+
+#[sealed]
+impl lets::attempt::some::nesting::LongerSnakeCaseType for B {}
+
+fn main() {
+    return;
+}

examples/simple.rs

@@ -0,0 +1,16 @@
+use sealed::sealed;
+
+#[sealed]
+pub trait T {}
+
+pub struct A;
+pub struct B(i32);
+
+#[sealed]
+impl T for A {}
+#[sealed]
+impl T for B {}
+
+fn main() {
+    return;
+}

examples/syn.rs

@@ -0,0 +1,44 @@
+// Example provided in #4
+// https://github.com/jmg-duarte/sealed-rs/issues/4
+
+use proc_macro2::*;
+use sealed::sealed;
+use syn::spanned::Spanned;
+
+#[sealed]
+pub trait AsSpan {
+    fn as_span(&self) -> Span;
+}
+// expands to:
+// pub trait AsSpan: __seal_for_as_span::Sealed {
+//     fn as_span(&self) -> Span;
+// }
+// mod __seal_for_as_span {
+//     pub trait Sealed {}
+// }
+
+#[sealed]
+impl AsSpan for Span {
+    fn as_span(&self) -> Self {
+        *self
+    }
+}
+// expands to:
+// impl AsSpan for Span {  // foreign type, cannot place #[sealed]
+//     fn as_span(&self) -> Self { *self }
+// }
+// impl __seal_for_as_span::Sealed for Span {}
+
+#[sealed]
+impl<T: Spanned> AsSpan for &T {
+    fn as_span(&self) -> Span {
+        self.span()
+    }
+}
+// expands to:
+// impl<T: Spanned> AsSpan for &T {
+//     fn as_span(&self) -> Span { self.span() }
+// }
+// impl<T: Spanned> __seal_for_as_span::Sealed for &T {}
+
+fn main() {}

src/lib.rs

@@ -62,9 +62,11 @@
 //! impl private::Sealed for A {}
 //! ```
 
+use heck::SnakeCase;
 use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse_macro_input, parse_quote};
+use syn::{ext::IdentExt, parse_macro_input, parse_quote};
 
 #[proc_macro_attribute]
 pub fn sealed(_args: TokenStream, input: TokenStream) -> TokenStream {
@@ -75,10 +77,14 @@ pub fn sealed(_args: TokenStream, input: TokenStream) -> TokenStream {
     })
 }
 
-fn parse_sealed(item: syn::Item) -> syn::Result<proc_macro2::TokenStream> {
+fn seal_name<D: ::std::fmt::Display>(seal: D) -> syn::Ident {
+    ::quote::format_ident!("__seal_for_{}", &seal.to_string().to_snake_case())
+}
+
+fn parse_sealed(item: syn::Item) -> syn::Result<TokenStream2> {
     match item {
-        syn::Item::Struct(item_struct) => parse_sealed_struct(item_struct),
-        syn::Item::Trait(item_trait) => parse_sealed_trait(item_trait),
+        syn::Item::Impl(item_impl) => parse_sealed_impl(item_impl),
+        syn::Item::Trait(item_trait) => Ok(parse_sealed_trait(item_trait)),
         _ => Err(syn::Error::new(
             proc_macro2::Span::call_site(),
             "expected struct or trait",
@@ -87,21 +93,42 @@ fn parse_sealed(item: syn::Item) -> syn::Result<proc_macro2::TokenStream> {
 }
 
 // Care for https://gist.github.com/Koxiaet/8c05ebd4e0e9347eb05f265dfb7252e1#procedural-macros-support-renaming-the-crate
-fn parse_sealed_struct(strct: syn::ItemStruct) -> syn::Result<proc_macro2::TokenStream> {
-    let ident = &strct.ident;
-    Ok(quote!(
-        #strct
-        impl private::Sealed for #ident {}
-    ))
+fn parse_sealed_trait(mut item_trait: syn::ItemTrait) -> TokenStream2 {
+    let trait_ident = &item_trait.ident.unraw();
+    let trait_generics = &item_trait.generics;
+    let seal = seal_name(trait_ident);
+    item_trait
+        .supertraits
+        .push(parse_quote!(#seal::Sealed #trait_generics));
+    quote!(
+        pub(crate) mod #seal {
+            pub trait Sealed #trait_generics {}
+        }
+        #item_trait
+    )
 }
 
-// Care for https://gist.github.com/Koxiaet/8c05ebd4e0e9347eb05f265dfb7252e1#procedural-macros-support-renaming-the-crate
-fn parse_sealed_trait(mut trt: syn::ItemTrait) -> syn::Result<proc_macro2::TokenStream> {
-    trt.supertraits.push(parse_quote!(private::Sealed));
-    Ok(quote!(
-        #trt
-        mod private {
-            pub trait Sealed {}
-        }
-    ))
+fn parse_sealed_impl(item_impl: syn::ItemImpl) -> syn::Result<TokenStream2> {
+    if let Some(impl_trait) = &item_impl.trait_ {
+        let mut sealed_path = impl_trait.1.segments.clone();
+        // since `impl for ...` is not allowed, this path will *always* have at least length 1
+        // thus both `first` and `last` are safe to unwrap
+        let syn::PathSegment { ident, arguments } = sealed_path.pop().unwrap().into_value();
+        let seal = seal_name(ident);
+        sealed_path.push(parse_quote!(#seal));
+        sealed_path.push(parse_quote!(Sealed));
+
+        let self_type = &item_impl.self_ty;
+        let trait_generics = &item_impl.generics.split_for_impl().1;
+
+        Ok(quote! {
+            impl #trait_generics #sealed_path #arguments for #self_type {}
+            #item_impl
+        })
+    } else {
+        Err(syn::Error::new_spanned(
+            item_impl,
+            "missing implentation trait",
+        ))
+    }
 }

tests/compile/01.rs → tests/fail/01-general.rs

@@ -1,18 +1,22 @@
 use sealed::sealed;
 
-#[sealed]
 pub struct A;
-#[sealed]
+
 pub struct B {
     field_1: i32,
 }
+
 pub struct C;
 
 #[sealed]
 trait T {}
 
+#[sealed]
 impl T for A {}
+
+#[sealed]
 impl T for B {}
+
 impl T for C {}
 
 fn main() {

tests/compile/01.stderr → tests/fail/01-general.stderr

@@ -1,10 +1,10 @@
 error[E0277]: the trait bound `C: Sealed` is not satisfied
-  --> $DIR/01.rs:16:6
+  --> $DIR/01-general.rs:20:6
    |
 11 | #[sealed]
    | --------- required by this bound in `T`
 12 | trait T {}
    |       - required by a bound in this
 ...
-16 | impl T for C {}
+20 | impl T for C {}
    |      ^ the trait `Sealed` is not implemented for `C`