From 85520ea39dac0d52204b160c0408511cf659d8d2 Mon Sep 17 00:00:00 2001
From: Taiki Endo <te316e89@gmail.com>
Date: Tue, 25 Aug 2020 14:32:45 +0900
Subject: [PATCH] Remove dependency on proc-macro2

---
 Cargo.toml       |  1 -
 src/ast.rs       | 17 ++++++++++++-----
 src/lib.rs       | 21 ++++++++++-----------
 src/to_tokens.rs | 16 +---------------
 src/utils.rs     |  4 ++--
 5 files changed, 25 insertions(+), 34 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 093f9f4..b2bda08 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,4 +27,3 @@ proc-macro = true
 version_check = "0.9.2"
 
 [dependencies]
-proc-macro2 = "1.0"
diff --git a/src/ast.rs b/src/ast.rs
index 961e9ab..b9acee5 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -1,4 +1,4 @@
-use proc_macro2::{Delimiter, Literal, Span, TokenStream, TokenTree};
+use proc_macro::{Delimiter, Literal, Span, TokenStream, TokenTree};
 use std::iter::Peekable;
 
 use crate::{
@@ -23,17 +23,22 @@ pub(crate) fn parse_input(input: TokenStream) -> Result<Func> {
     parse_as_empty(input)?;
 
     if body.is_none()
-        || !sig.iter().any(|tt| if let TokenTree::Ident(i) = tt { i == "fn" } else { false })
+        || !sig
+            .iter()
+            .any(|tt| if let TokenTree::Ident(i) = tt { i.to_string() == "fn" } else { false })
     {
         return Err(error!(
             Span::call_site(),
             "#[const_fn] attribute may only be used on functions"
         ));
     }
-    if !sig.iter().any(|tt| if let TokenTree::Ident(i) = tt { i == "const" } else { false }) {
+    if !sig
+        .iter()
+        .any(|tt| if let TokenTree::Ident(i) = tt { i.to_string() == "const" } else { false })
+    {
         let span = sig
             .iter()
-            .position(|tt| if let TokenTree::Ident(i) = tt { i == "fn" } else { false })
+            .position(|tt| if let TokenTree::Ident(i) = tt { i.to_string() == "fn" } else { false })
             .map(|i| sig[i].span())
             .unwrap();
         return Err(error!(span, "#[const_fn] attribute may only be used on const functions"));
@@ -50,7 +55,9 @@ impl ToTokens for Func {
         } else {
             self.sig
                 .iter()
-                .filter(|tt| if let TokenTree::Ident(i) = tt { i != "const" } else { true })
+                .filter(
+                    |tt| if let TokenTree::Ident(i) = tt { i.to_string() != "const" } else { true },
+                )
                 .for_each(|tt| tt.to_tokens(tokens));
         }
         self.body.to_tokens(tokens);
diff --git a/src/lib.rs b/src/lib.rs
index 774a480..5d43ff1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -54,8 +54,7 @@ mod ast;
 mod error;
 mod to_tokens;
 
-use proc_macro::TokenStream;
-use proc_macro2::{Delimiter, TokenStream as TokenStream2, TokenTree};
+use proc_macro::{Delimiter, TokenStream, TokenTree};
 use std::str::FromStr;
 
 use crate::{
@@ -70,11 +69,11 @@ pub(crate) type Result<T, E = Error> = std::result::Result<T, E>;
 /// See crate level documentation for details.
 #[proc_macro_attribute]
 pub fn const_fn(args: TokenStream, input: TokenStream) -> TokenStream {
-    let arg = match parse_arg(args.into()) {
+    let arg = match parse_arg(args) {
         Ok(a) => a,
         Err(e) => return e.to_compile_error(),
     };
-    let mut func = match ast::parse_input(input.into()) {
+    let mut func = match ast::parse_input(input) {
         Ok(i) => i,
         Err(e) => return e.to_compile_error(),
     };
@@ -86,7 +85,7 @@ pub fn const_fn(args: TokenStream, input: TokenStream) -> TokenStream {
             tokens.extend(cfg_not);
             func.print_const = false;
             tokens.extend(func.to_token_stream());
-            tokens.into()
+            tokens
         }
         Arg::Feature(f) => {
             let (mut tokens, cfg_not) = cfg_attrs(f);
@@ -94,19 +93,19 @@ pub fn const_fn(args: TokenStream, input: TokenStream) -> TokenStream {
             tokens.extend(cfg_not);
             func.print_const = false;
             tokens.extend(func.to_token_stream());
-            tokens.into()
+            tokens
         }
         Arg::Version(req) => {
             if req.major > 1 || req.minor > VERSION.minor {
                 func.print_const = false;
             }
-            func.to_token_stream().into()
+            func.to_token_stream()
         }
         Arg::Nightly => {
             if !VERSION.nightly {
                 func.print_const = false;
             }
-            func.to_token_stream().into()
+            func.to_token_stream()
         }
     }
 }
@@ -117,12 +116,12 @@ enum Arg {
     // `const_fn(nightly)`
     Nightly,
     // `const_fn(cfg(...))`
-    Cfg(TokenStream2),
+    Cfg(TokenStream),
     // `const_fn(feature = "...")`
-    Feature(TokenStream2),
+    Feature(TokenStream),
 }
 
-fn parse_arg(tokens: TokenStream2) -> Result<Arg> {
+fn parse_arg(tokens: TokenStream) -> Result<Arg> {
     let tokens2 = tokens.clone();
     let mut iter = tokens.into_iter();
 
diff --git a/src/to_tokens.rs b/src/to_tokens.rs
index 646a5e0..6cc51fd 100644
--- a/src/to_tokens.rs
+++ b/src/to_tokens.rs
@@ -1,4 +1,4 @@
-use proc_macro2::*;
+use proc_macro::*;
 use std::iter;
 
 pub(crate) trait ToTokens {
@@ -34,17 +34,3 @@ impl ToTokens for TokenStream {
         tokens.extend(self.clone());
     }
 }
-
-impl<T: ToTokens> ToTokens for Option<T> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        if let Some(t) = self {
-            T::to_tokens(t, tokens);
-        }
-    }
-}
-
-impl<T: ToTokens> ToTokens for &T {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        T::to_tokens(*self, tokens);
-    }
-}
diff --git a/src/utils.rs b/src/utils.rs
index 561a812..78be0a9 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,11 +1,11 @@
-use proc_macro2::*;
+use proc_macro::*;
 use std::iter::FromIterator;
 
 use crate::Result;
 
 macro_rules! error {
     ($span:expr, $msg:expr) => {{
-        crate::error::Error::new($span.unwrap(), $msg)
+        crate::error::Error::new($span, $msg)
     }};
     ($span:expr, $($tt:tt)*) => {
         error!($span, format!($($tt)*))