Proc macro hack

dtolnay · dtolnay · commit c6cb01100b28 · 2016-12-30T14:29:23.000-08:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,2 @@
+target
+Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "proc-macro-hack"
+version = "0.1.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Procedural functionlike!() macros using only Macros 1.1"
+repository = "https://github.com/dtolnay/proc-macro-hack"
diff --git a/README.md b/README.md
@@ -0,0 +1,122 @@
+Procedural functionlike!() macros using only Macros 1.1
+=======================================================
+
+[![Build Status](https://api.travis-ci.org/dtolnay/proc-macro-hack.svg?branch=master)](https://travis-ci.org/dtolnay/proc-macro-hack)
+[![Latest Version](https://img.shields.io/crates/v/proc-macro-hack.svg)](https://crates.io/crates/proc-macro-hack)
+
+Did you think Macros 1.1 was only for custom derives? Think again.
+
+## Defining procedural macros
+
+Two crates are required to define a macro.
+
+### The declaration crate
+
+This crate is allowed to contain other public things if you need, for example
+traits or functions or ordinary macros.
+
+https://github.com/dtolnay/proc-macro-hack/tree/master/demo-hack
+
+```rust
+#![feature(proc_macro)]
+
+#[macro_use] extern crate proc_macro_hack;
+#[macro_use] extern crate proc_macro_hack_impl;
+
+/// Add one to an expression.
+proc_macro_expr_decl!(add_one! => add_one_impl);
+
+/// A function that always returns 2.
+proc_macro_item_decl!(two_fn! => two_fn_impl);
+```
+
+### The implementation crate
+
+This crate must contain nothing but procedural macros. Private helper functions
+and private modules are fine but nothing can be public.
+
+https://github.com/dtolnay/proc-macro-hack/tree/master/demo-hack-impl
+
+```rust
+#![feature(proc_macro, proc_macro_lib)]
+
+#[macro_use] extern crate proc_macro_hack;
+#[macro_use] extern crate proc_macro_hack_impl;
+
+proc_macro_expr_impl! {
+    /// Add one to an expression.
+    pub fn add_one_impl(input: &str) -> Result<String, String> {
+        Ok(format!("1 + {}", input))
+    }
+}
+
+proc_macro_item_impl! {
+    /// A function that always returns 2.
+    pub fn two_fn_impl(input: &str) -> Result<String, String> {
+        Ok(format!("fn {}() -> u8 {{ 2 }}", input))
+    }
+}
+```
+
+Both crates depend on `proc-macro-hack` which itself has a declaration crate and
+implementation crate:
+
+```toml
+[dependencies]
+proc-macro-hack = "0.1"
+proc-macro-hack-impl = "0.1"
+```
+
+Additionally, your implementation crate (but not your declaration crate) is a
+proc macro:
+
+```toml
+[lib]
+proc-macro = true
+```
+
+## Using procedural macros
+
+Users of your crate depend on your declaration crate and implementation crate,
+then use your procedural macros as though it were magic. They even get
+reasonable error messages if your procedural macro returns an error.
+
+https://github.com/dtolnay/proc-macro-hack/tree/master/example
+
+```rust
+#![feature(proc_macro)]
+
+#[macro_use] extern crate demo_hack;
+#[macro_use] extern crate demo_hack_impl;
+
+two_fn!(two);
+
+fn main() {
+    let x = two();
+    let nine = add_one!(x) + add_one!(2 + 3);
+    println!("nine = {}", nine);
+}
+```
+
+## Limitations
+
+- The input to your macro cannot contain dollar signs.
+- Users of your macro need to `#[macro_use] extern crate` two different crates,
+  not just one.
+- Your macro must expand to either an expression or zero-or-more items, cannot
+  sometimes be one or the other depending on input.
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
diff --git a/demo-hack-impl/Cargo.toml b/demo-hack-impl/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "demo-hack-impl"
+version = "0.1.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro-hack = { path = ".." }
+proc-macro-hack-impl = { path = "../impl" }
diff --git a/demo-hack-impl/src/lib.rs b/demo-hack-impl/src/lib.rs
@@ -0,0 +1,18 @@
+#![feature(proc_macro, proc_macro_lib)]
+
+#[macro_use] extern crate proc_macro_hack;
+#[macro_use] extern crate proc_macro_hack_impl;
+
+proc_macro_expr_impl! {
+    /// Add one to an expression.
+    pub fn add_one_impl(input: &str) -> Result<String, String> {
+        Ok(format!("1 + {}", input))
+    }
+}
+
+proc_macro_item_impl! {
+    /// A function that always returns 2.
+    pub fn two_fn_impl(input: &str) -> Result<String, String> {
+        Ok(format!("fn {}() -> u8 {{ 2 }}", input))
+    }
+}
diff --git a/demo-hack/Cargo.toml b/demo-hack/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "demo-hack"
+version = "0.1.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+
+[dependencies]
+proc-macro-hack = { path = ".." }
+proc-macro-hack-impl = { path = "../impl" }
diff --git a/demo-hack/src/lib.rs b/demo-hack/src/lib.rs
@@ -0,0 +1,10 @@
+#![feature(proc_macro)]
+
+#[macro_use] extern crate proc_macro_hack;
+#[macro_use] extern crate proc_macro_hack_impl;
+
+/// Add one to an expression.
+proc_macro_expr_decl!(add_one! => add_one_impl);
+
+/// A function that always returns 2.
+proc_macro_item_decl!(two_fn! => two_fn_impl);
diff --git a/example/Cargo.toml b/example/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "example"
+version = "0.1.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+
+[dependencies]
+demo-hack = { path = "../demo-hack" }
+demo-hack-impl = { path = "../demo-hack-impl" }
+proc-macro-hack = { path = ".." }
diff --git a/example/src/main.rs b/example/src/main.rs
@@ -0,0 +1,12 @@
+#![feature(proc_macro)]
+
+#[macro_use] extern crate demo_hack;
+#[macro_use] extern crate demo_hack_impl;
+
+two_fn!(two);
+
+fn main() {
+    let x = two();
+    let nine = add_one!(x) + add_one!(2 + 3);
+    println!("nine = {}", nine);
+}
diff --git a/impl/Cargo.toml b/impl/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "proc-macro-hack-impl"
+version = "0.1.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Procedural functionlike!() macros using only Macros 1.1"
+repository = "https://github.com/dtolnay/proc-macro-hack"
+
+[lib]
+proc-macro = true
diff --git a/impl/src/lib.rs b/impl/src/lib.rs
@@ -0,0 +1,61 @@
+#![feature(proc_macro, proc_macro_lib)]
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(ProcMacroHackExpr)]
+pub fn hack_expr(input: TokenStream) -> TokenStream {
+    let (name, name_impl) = names(input);
+
+    let rules = format!("
+        #[macro_export]
+        macro_rules! {} {{
+            ($($tt:tt)*) => {{{{
+                #[derive({})]
+                #[allow(unused)]
+                enum ProcMacroHack {{
+                    Input = {{ stringify!($($tt)*); 0 }}
+                }}
+
+                proc_macro_call!()
+            }}}}
+        }}
+    ", name, name_impl);
+
+    rules.parse().unwrap()
+}
+
+#[proc_macro_derive(ProcMacroHackItem)]
+pub fn hack_item(input: TokenStream) -> TokenStream {
+    let (name, name_impl) = names(input);
+
+    let rules = format!("
+        #[macro_export]
+        macro_rules! {} {{
+            ($($tt:tt)*) => {{
+                #[derive({})]
+                #[allow(unused)]
+                enum ProcMacroHack {{
+                    Input = {{ stringify!($($tt)*); 0 }}
+                }}
+            }}
+        }}
+    ", name, name_impl);
+
+    rules.parse().unwrap()
+}
+
+fn names(input: TokenStream) -> (String, String) {
+    let source = input.to_string();
+
+    let mut words = source.split_whitespace();
+    assert_eq!(Some("#[allow(unused)]"), words.next());
+    assert_eq!(Some("enum"), words.next());
+    let name = words.next().unwrap();
+    assert_eq!(Some("{"), words.next());
+    let name_impl = words.next().unwrap();
+    assert_eq!(Some("}"), words.next());
+    assert_eq!(None, words.next());
+
+    (name.to_owned(), name_impl.to_owned())
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -0,0 +1,97 @@
+#![feature(proc_macro_lib)]
+
+extern crate proc_macro;
+
+#[doc(hidden)]
+pub use proc_macro::TokenStream;
+
+#[macro_export]
+macro_rules! proc_macro_expr_decl {
+    ($name:ident ! => $name_impl:ident) => {
+        #[derive(ProcMacroHackExpr)]
+        #[allow(unused)]
+        enum $name {
+            $name_impl
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! proc_macro_item_decl {
+    ($name:ident ! => $name_impl:ident) => {
+        #[derive(ProcMacroHackItem)]
+        #[allow(unused)]
+        enum $name {
+            $name_impl
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! proc_macro_expr_impl {
+    ($(
+        $( #[$attr:meta] )*
+        pub fn $func:ident($input:ident: &str ) -> Result<String, String> $body:block
+    )+) => {
+        $(
+            $( #[$attr] )*
+            #[proc_macro_derive($func)]
+            pub fn $func(input: $crate::TokenStream) -> $crate::TokenStream {
+                let source = input.to_string();
+
+                let prefix = "#[allow(unused)]\nenum ProcMacroHack { Input = { stringify!(";
+                let suffix = "); 0 }, }\n";
+                if !(source.starts_with(prefix) && source.ends_with(suffix)) {
+                    panic!("`{}` procedural macro failed", stringify!($func));
+                }
+
+                let tokens = &source[prefix.len() .. source.len() - suffix.len()];
+
+                fn func($input: &str) -> Result<String, String> $body
+
+                let wrap = match func(tokens) {
+                    Ok(expr) => {
+                        format!("
+                            macro_rules! proc_macro_call {{
+                                ($($tt:tt)*) => {{
+                                    {}
+                                }}
+                            }}
+                        ", expr)
+                    }
+                    Err(msg) => panic!(msg)
+                };
+
+                wrap.parse().unwrap()
+            }
+        )+
+    }
+}
+
+#[macro_export]
+macro_rules! proc_macro_item_impl {
+    ($(
+        $( #[$attr:meta] )*
+        pub fn $func:ident($input:ident: &str ) -> Result<String, String> $body:block
+    )+) => {
+        $(
+            $( #[$attr] )*
+            #[proc_macro_derive($func)]
+            pub fn $func(input: $crate::TokenStream) -> $crate::TokenStream {
+                let source = input.to_string();
+
+                let prefix = "#[allow(unused)]\nenum ProcMacroHack { Input = { stringify!(";
+                let suffix = "); 0 }, }\n";
+                if !(source.starts_with(prefix) && source.ends_with(suffix)) {
+                    panic!("`{}` procedural macro failed", stringify!($func));
+                }
+
+                let tokens = &source[prefix.len() .. source.len() - suffix.len()];
+
+                fn func($input: &str) -> Result<String, String> $body
+
+                func(tokens).unwrap_or_else(|msg| panic!(msg)).parse().unwrap()
+            }
+        )+
+    }
+}
