proc_macro: reexport most of the proc-macro2 public API.

README.md

@@ -11,12 +11,10 @@ Easiest way to get started is through `gll-macros`:
 [dependencies]
 gll = "0.0.2"
 gll-macros = "0.0.2"
-proc-macro2 = "0.4.20"
 ```
 ```rust
 extern crate gll;
 extern crate gll_macros;
-extern crate proc_macro2;
 ```
 
 As an example, this is what you might write for a JSON-like syntax,
@@ -42,9 +40,7 @@ You can also use a build script to generate the parser (**TODO**: document).
 
 To parse a string with that grammar:
 ```rust
-use proc_macro2::TokenStream;
-
-let tokens: TokenStream = string.parse().unwrap();
+let tokens = string.parse::<::gll::proc_macro::TokenStream>().unwrap();
 json_like::Value::parse_with(tokens, |parser, result| {
     let value = result.unwrap();
     // ...

macros/tests/json.rs

@@ -19,31 +19,30 @@ mod json_like {
 
 #[test]
 fn json_like_proc_macro() {
-    json_like::Value::parse_with(
-        quote::quote! {
-            // Example from `serde_json`.
-            {
-                name: "John Doe",
-                age: 43,
-                address: {
-                    street: "10 Downing Street",
-                    city: "London"
-                },
-                phones: [
-                    "+44 1234567",
-                    "+44 2345678"
-                ],
+    let tokens: ::gll::proc_macro::TokenStream = quote::quote! {
+        // Example from `serde_json`.
+        {
+            name: "John Doe",
+            age: 43,
+            address: {
+                street: "10 Downing Street",
+                city: "London"
+            },
+            phones: [
+                "+44 1234567",
+                "+44 2345678"
+            ],
 
-                test: [null, false, true, (format!("{:?}", Some(1 + 2)))]
-            }
-        },
-        |_, result| {
-            let result = format!("{:#?}", result.unwrap());
-            // HACK(eddyb) clean up the result, as we have no span info.
-            let result = result
-                .replace("Span..Span => ", "")
-                .replace("Span..Span", "?");
-            let expected = "\
+            test: [null, false, true, (format!("{:?}", Some(1 + 2)))]
+        }
+    };
+    json_like::Value::parse_with(tokens, |_, result| {
+        let result = format!("{:#?}", result.unwrap());
+        // HACK(eddyb) clean up the result, as we have no span info.
+        let result = result
+            .replace("Span..Span => ", "")
+            .replace("Span..Span", "?");
+        let expected = "\
 Value::Object {
     fields: [
         Field {
@@ -116,12 +115,11 @@ Value::Object {
             let normalize = |s: &str| {
                 s.replace(",\n", "\n")
             };
-            assert!(
-                normalize(&result) == normalize(expected),
-                "mismatched output, expected:\n{}\n\nfound:\n{}",
-                expected,
-                result
-            );
-        },
-    )
+        assert!(
+            normalize(&result) == normalize(expected),
+            "mismatched output, expected:\n{}\n\nfound:\n{}",
+            expected,
+            result
+        );
+    })
 }

src/proc_macro.rs

@@ -1,7 +1,7 @@
 use generate::rust::RustInputPat;
 use grammar::{self, call, eat, MatchesEmpty, MaybeKnown};
 use indexing::Container;
-use proc_macro2::{
+pub use proc_macro2::{
     Delimiter, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree,
 };
 use runtime::{Input, InputMatch, Range};