Fix issues #4 and #5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sealed"
-version = "0.1.3"
+version = "0.2.0-rc3"
 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,11 @@ categories = ["development-tools", "rust-patterns"]
 keywords = ["proc_macro", "sealed", "future-proofing"]
 readme = "README.md"
 edition = "2018"
-exclude = [
-    "images/*"
-]
+exclude = ["images/*"]
+resolver = "2"
 
 [workspace]
-members = [
-    "demo"
-]
+members = ["demo"]
 
 [lib]
 proc-macro = true
@@ -29,4 +26,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-rc3"
 ```
 
 ## 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;
@@ -45,25 +45,66 @@ fn main() {
 }
 ```
 
+## Attributes
+
+This is the list of attributes that can be used along `#[sealed]`:
+- `#[sealed]`: the main attribute macro, without attribute parameters.
+- `#[sealed(erase)]`: this option turns on bound erasure. This is useful when using the `#[sealed]` macro inside a function.
+For an example, see [`bound-erasure-fn`](tests/pass/08-bound-erasure-fn.rs).
+
 ## 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_t {
+    pub trait Sealed {}
 }
+pub trait T: __seal_t::Sealed {}
 
-// #[sealed]
-// pub struct A;
 pub struct A;
-impl private::Sealed for A {}
+pub struct B(i32);
+
+impl __seal_t::Sealed for A {}
+impl T for A {}
+
+impl __seal_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/bound-erasure-fn.rs

@@ -0,0 +1,14 @@
+use sealed::sealed;
+
+fn main() {
+    trait Foo {}
+    trait Bar {}
+
+    #[sealed(erase)]
+    trait Trait<T: ?Sized + Foo> {}
+
+    struct Implementor {}
+
+    #[sealed(erase)]
+    impl<T: ?Sized> Trait<T> for Implementor where T: Foo + Bar {}
+}

examples/bound-erasure.rs

@@ -0,0 +1,5 @@
+use sealed::sealed;
+trait Foo {}
+#[sealed(erase)]
+trait Trait<T: ?Sized + Foo> {}
+fn main() {}

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/raw-ident.rs

@@ -0,0 +1,12 @@
+use sealed::sealed;
+
+#[sealed]
+pub trait r#Pub<V> {}
+
+#[sealed]
+impl<T> r#Pub<Option<T>> for T {}
+
+#[sealed]
+impl<T> r#Pub<Option<T>> for Option<T> {}
+
+fn main() {}

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_as_span::Sealed {
+//     fn as_span(&self) -> Span;
+// }
+// mod __seal_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_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_as_span::Sealed for &T {}
+
+fn main() {}