Update to latest quote-1.0.3 am: a8f5053a43

Change-Id: I676d5bb23141a27f4d8231adad4a103f884c16ce

13 files changed, 131 insertions, 111 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index c5b6105..5388292 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "727436c6c137b20f0f34dde5d8fda2679b9747ad"
+    "sha1": "e0300930fa4a8b448c4ff39f499dd4d2fcb0f17d"
   }
 }
diff --git a/Android.bp b/Android.bp
index 2a3cb09..2fbcffe 100644
--- a/Android.bp
+++ b/Android.bp
@@ -13,3 +13,7 @@ rust_library_host_rlib {
         "libproc_macro2",
     ],
 }
+
+// dependent_library ["feature_list"]
+//   proc-macro2-1.0.9 "default,proc-macro"
+//   unicode-xid-0.2.0 "default"
diff --git a/Cargo.toml b/Cargo.toml
index a7a956d..fa5dc59 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "quote"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 description = "Quasi-quoting macro quote!(...)"
@@ -23,17 +23,15 @@ keywords = ["syn"]
 categories = ["development-tools::procedural-macro-helpers"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/dtolnay/quote"
-
-[lib]
-name = "quote"
 [dependencies.proc-macro2]
 version = "1.0"
 default-features = false
 [dev-dependencies.rustversion]
-version = "0.1"
+version = "1.0"
 
 [dev-dependencies.trybuild]
-version = "1.0"
+version = "1.0.19"
+features = ["diff"]
 
 [features]
 default = ["proc-macro"]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index c052022..ae3963f 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "quote"
-version = "1.0.2" # don't forget to update html_root_url, version in readme for breaking changes
+version = "1.0.3" # don't forget to update html_root_url, version in readme for breaking changes
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Quasi-quoting macro quote!(...)"
@@ -12,15 +12,12 @@ readme = "README.md"
 include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 edition = "2018"
 
-[lib]
-name = "quote"
-
 [dependencies]
 proc-macro2 = { version = "1.0", default-features = false }
 
 [dev-dependencies]
-rustversion = "0.1"
-trybuild = "1.0"
+rustversion = "1.0"
+trybuild = { version = "1.0.19", features = ["diff"] }
 
 [features]
 default = ["proc-macro"]
diff --git a/LICENSE b/LICENSE
new file mode 120000
index 0000000..6b579aa
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1 @@
+LICENSE-APACHE
\ No newline at end of file
diff --git a/METADATA b/METADATA
new file mode 100644
index 0000000..3684f12
--- /dev/null
+++ b/METADATA
@@ -0,0 +1,18 @@
+name: "quote"
+description: "This crate provides the quote! macro for turning Rust syntax tree data structures into tokens of source code."
+third_party {
+  url {
+    type: HOMEPAGE
+    value: "https://crates.io/crates/quote"
+  }
+  url {
+    type: GIT
+    value: "https://github.com/dtolnay/quote"
+  }
+  version: "1.0.3"
+  last_upgrade_date {
+    year: 2020
+    month: 3
+    day: 20
+  }
+}
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/NOTICE b/NOTICE
new file mode 120000
index 0000000..7a694c9
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1 @@
+LICENSE
\ No newline at end of file
diff --git a/src/format.rs b/src/format.rs
index 13c8811..745cb5d 100644
--- a/src/format.rs
+++ b/src/format.rs
@@ -128,7 +128,7 @@ macro_rules! format_ident {
 macro_rules! format_ident_impl {
     // Final state
     ([$span:expr, $($fmt:tt)*]) => {
-        $crate::__rt::mk_ident(&format!($($fmt)*), $span)
+        $crate::__private::mk_ident(&format!($($fmt)*), $span)
     };
 
     // Span argument
@@ -137,7 +137,7 @@ macro_rules! format_ident_impl {
     };
     ([$old:expr, $($fmt:tt)*] span = $span:expr, $($rest:tt)*) => {
         $crate::format_ident_impl!([
-            ::std::option::Option::Some::<$crate::__rt::Span>($span),
+            ::std::option::Option::Some::<$crate::__private::Span>($span),
             $($fmt)*
         ] $($rest)*)
     };
@@ -147,7 +147,7 @@ macro_rules! format_ident_impl {
         $crate::format_ident_impl!([$span, $($fmt)*] $name = $arg,)
     };
     ([$span:expr, $($fmt:tt)*] $name:ident = $arg:expr, $($rest:tt)*) => {
-        match $crate::__rt::IdentFragmentAdapter(&$arg) {
+        match $crate::__private::IdentFragmentAdapter(&$arg) {
             arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt)*, $name = arg] $($rest)*),
         }
     };
@@ -157,7 +157,7 @@ macro_rules! format_ident_impl {
         $crate::format_ident_impl!([$span, $($fmt)*] $arg,)
     };
     ([$span:expr, $($fmt:tt)*] $arg:expr, $($rest:tt)*) => {
-        match $crate::__rt::IdentFragmentAdapter(&$arg) {
+        match $crate::__private::IdentFragmentAdapter(&$arg) {
             arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt)*, arg] $($rest)*),
         }
     };
diff --git a/src/ident_fragment.rs b/src/ident_fragment.rs
index 09ead65..7e5d376 100644
--- a/src/ident_fragment.rs
+++ b/src/ident_fragment.rs
@@ -19,7 +19,7 @@ pub trait IdentFragment {
     }
 }
 
-impl<'a, T: IdentFragment + ?Sized> IdentFragment for &'a T {
+impl<T: IdentFragment + ?Sized> IdentFragment for &T {
     fn span(&self) -> Option<Span> {
         <T as IdentFragment>::span(*self)
     }
@@ -29,7 +29,7 @@ impl<'a, T: IdentFragment + ?Sized> IdentFragment for &'a T {
     }
 }
 
-impl<'a, T: IdentFragment + ?Sized> IdentFragment for &'a mut T {
+impl<T: IdentFragment + ?Sized> IdentFragment for &mut T {
     fn span(&self) -> Option<Span> {
         <T as IdentFragment>::span(*self)
     }
diff --git a/src/lib.rs b/src/lib.rs
index 3341a16..ad12230 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -72,8 +72,10 @@
 //! };
 //! ```
 
+#![forbid(unsafe_code)]
+
 // Quote types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/quote/1.0.2")]
+#![doc(html_root_url = "https://docs.rs/quote/1.0.3")]
 
 #[cfg(all(
     not(all(target_arch = "wasm32", target_os = "unknown")),
@@ -89,7 +91,7 @@ mod to_tokens;
 // Not public API.
 #[doc(hidden)]
 #[path = "runtime.rs"]
-pub mod __rt;
+pub mod __private;
 
 pub use crate::ext::TokenStreamExt;
 pub use crate::ident_fragment::IdentFragment;
@@ -463,7 +465,7 @@ pub mod spanned;
 #[macro_export]
 macro_rules! quote {
     ($($tt:tt)*) => {
-        $crate::quote_spanned!($crate::__rt::Span::call_site()=> $($tt)*)
+        $crate::quote_spanned!($crate::__private::Span::call_site()=> $($tt)*)
     };
 }
 
@@ -566,8 +568,8 @@ macro_rules! quote {
 #[macro_export]
 macro_rules! quote_spanned {
     ($span:expr=> $($tt:tt)*) => {{
-        let mut _s = $crate::__rt::TokenStream::new();
-        let _span: $crate::__rt::Span = $span;
+        let mut _s = $crate::__private::TokenStream::new();
+        let _span: $crate::__private::Span = $span;
         $crate::quote_each_token!(_s _span $($tt)*);
         _s
     }};
@@ -638,7 +640,7 @@ macro_rules! quote_bind_into_iter {
 macro_rules! quote_bind_next_or_break {
     ($var:ident) => {
         let $var = match $var.next() {
-            Some(_x) => $crate::__rt::RepInterp(_x),
+            Some(_x) => $crate::__private::RepInterp(_x),
             None => break,
         };
     };
@@ -680,10 +682,10 @@ macro_rules! quote_token_with_context {
     ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
 
     ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{
-        use $crate::__rt::ext::*;
-        let has_iter = $crate::__rt::ThereIsNoIteratorInRepetition;
+        use $crate::__private::ext::*;
+        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
         $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__rt::HasIterator = has_iter;
+        let _: $crate::__private::HasIterator = has_iter;
         // This is `while true` instead of `loop` because if there are no
         // iterators used inside of this repetition then the body would not
         // contain any `break`, so the compiler would emit unreachable code
@@ -699,11 +701,11 @@ macro_rules! quote_token_with_context {
     ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
 
     ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{
-        use $crate::__rt::ext::*;
+        use $crate::__private::ext::*;
         let mut _i = 0usize;
-        let has_iter = $crate::__rt::ThereIsNoIteratorInRepetition;
+        let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
         $crate::pounded_var_names!(quote_bind_into_iter!(has_iter) () $($inner)*);
-        let _: $crate::__rt::HasIterator = has_iter;
+        let _: $crate::__private::HasIterator = has_iter;
         while true {
             $crate::pounded_var_names!(quote_bind_next_or_break!() () $($inner)*);
             if _i > 0 {
@@ -735,214 +737,218 @@ macro_rules! quote_token_with_context {
 macro_rules! quote_token {
     ($tokens:ident $span:ident ( $($inner:tt)* )) => {
         $tokens.extend({
-            let mut g = $crate::__rt::Group::new(
-                $crate::__rt::Delimiter::Parenthesis,
+            let mut g = $crate::__private::Group::new(
+                $crate::__private::Delimiter::Parenthesis,
                 $crate::quote_spanned!($span=> $($inner)*),
             );
             g.set_span($span);
-            Some($crate::__rt::TokenTree::from(g))
+            Some($crate::__private::TokenTree::from(g))
         });
     };
 
     ($tokens:ident $span:ident [ $($inner:tt)* ]) => {
         $tokens.extend({
-            let mut g = $crate::__rt::Group::new(
-                $crate::__rt::Delimiter::Bracket,
+            let mut g = $crate::__private::Group::new(
+                $crate::__private::Delimiter::Bracket,
                 $crate::quote_spanned!($span=> $($inner)*),
             );
             g.set_span($span);
-            Some($crate::__rt::TokenTree::from(g))
+            Some($crate::__private::TokenTree::from(g))
         });
     };
 
     ($tokens:ident $span:ident { $($inner:tt)* }) => {
         $tokens.extend({
-            let mut g = $crate::__rt::Group::new(
-                $crate::__rt::Delimiter::Brace,
+            let mut g = $crate::__private::Group::new(
+                $crate::__private::Delimiter::Brace,
                 $crate::quote_spanned!($span=> $($inner)*),
             );
             g.set_span($span);
-            Some($crate::__rt::TokenTree::from(g))
+            Some($crate::__private::TokenTree::from(g))
         });
     };
 
     ($tokens:ident $span:ident +) => {
-        $crate::__rt::push_add(&mut $tokens, $span);
+        $crate::__private::push_add(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident +=) => {
-        $crate::__rt::push_add_eq(&mut $tokens, $span);
+        $crate::__private::push_add_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident &) => {
-        $crate::__rt::push_and(&mut $tokens, $span);
+        $crate::__private::push_and(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident &&) => {
-        $crate::__rt::push_and_and(&mut $tokens, $span);
+        $crate::__private::push_and_and(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident &=) => {
-        $crate::__rt::push_and_eq(&mut $tokens, $span);
+        $crate::__private::push_and_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident @) => {
-        $crate::__rt::push_at(&mut $tokens, $span);
+        $crate::__private::push_at(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident !) => {
-        $crate::__rt::push_bang(&mut $tokens, $span);
+        $crate::__private::push_bang(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ^) => {
-        $crate::__rt::push_caret(&mut $tokens, $span);
+        $crate::__private::push_caret(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ^=) => {
-        $crate::__rt::push_caret_eq(&mut $tokens, $span);
+        $crate::__private::push_caret_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident :) => {
-        $crate::__rt::push_colon(&mut $tokens, $span);
+        $crate::__private::push_colon(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ::) => {
-        $crate::__rt::push_colon2(&mut $tokens, $span);
+        $crate::__private::push_colon2(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ,) => {
-        $crate::__rt::push_comma(&mut $tokens, $span);
+        $crate::__private::push_comma(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident /) => {
-        $crate::__rt::push_div(&mut $tokens, $span);
+        $crate::__private::push_div(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident /=) => {
-        $crate::__rt::push_div_eq(&mut $tokens, $span);
+        $crate::__private::push_div_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident .) => {
-        $crate::__rt::push_dot(&mut $tokens, $span);
+        $crate::__private::push_dot(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ..) => {
-        $crate::__rt::push_dot2(&mut $tokens, $span);
+        $crate::__private::push_dot2(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ...) => {
-        $crate::__rt::push_dot3(&mut $tokens, $span);
+        $crate::__private::push_dot3(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ..=) => {
-        $crate::__rt::push_dot_dot_eq(&mut $tokens, $span);
+        $crate::__private::push_dot_dot_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident =) => {
-        $crate::__rt::push_eq(&mut $tokens, $span);
+        $crate::__private::push_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ==) => {
-        $crate::__rt::push_eq_eq(&mut $tokens, $span);
+        $crate::__private::push_eq_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident >=) => {
-        $crate::__rt::push_ge(&mut $tokens, $span);
+        $crate::__private::push_ge(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident >) => {
-        $crate::__rt::push_gt(&mut $tokens, $span);
+        $crate::__private::push_gt(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident <=) => {
-        $crate::__rt::push_le(&mut $tokens, $span);
+        $crate::__private::push_le(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident <) => {
-        $crate::__rt::push_lt(&mut $tokens, $span);
+        $crate::__private::push_lt(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident *=) => {
-        $crate::__rt::push_mul_eq(&mut $tokens, $span);
+        $crate::__private::push_mul_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident !=) => {
-        $crate::__rt::push_ne(&mut $tokens, $span);
+        $crate::__private::push_ne(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident |) => {
-        $crate::__rt::push_or(&mut $tokens, $span);
+        $crate::__private::push_or(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident |=) => {
-        $crate::__rt::push_or_eq(&mut $tokens, $span);
+        $crate::__private::push_or_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ||) => {
-        $crate::__rt::push_or_or(&mut $tokens, $span);
+        $crate::__private::push_or_or(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident #) => {
-        $crate::__rt::push_pound(&mut $tokens, $span);
+        $crate::__private::push_pound(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ?) => {
-        $crate::__rt::push_question(&mut $tokens, $span);
+        $crate::__private::push_question(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ->) => {
-        $crate::__rt::push_rarrow(&mut $tokens, $span);
+        $crate::__private::push_rarrow(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident <-) => {
-        $crate::__rt::push_larrow(&mut $tokens, $span);
+        $crate::__private::push_larrow(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident %) => {
-        $crate::__rt::push_rem(&mut $tokens, $span);
+        $crate::__private::push_rem(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident %=) => {
-        $crate::__rt::push_rem_eq(&mut $tokens, $span);
+        $crate::__private::push_rem_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident =>) => {
-        $crate::__rt::push_fat_arrow(&mut $tokens, $span);
+        $crate::__private::push_fat_arrow(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident ;) => {
-        $crate::__rt::push_semi(&mut $tokens, $span);
+        $crate::__private::push_semi(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident <<) => {
-        $crate::__rt::push_shl(&mut $tokens, $span);
+        $crate::__private::push_shl(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident <<=) => {
-        $crate::__rt::push_shl_eq(&mut $tokens, $span);
+        $crate::__private::push_shl_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident >>) => {
-        $crate::__rt::push_shr(&mut $tokens, $span);
+        $crate::__private::push_shr(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident >>=) => {
-        $crate::__rt::push_shr_eq(&mut $tokens, $span);
+        $crate::__private::push_shr_eq(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident *) => {
-        $crate::__rt::push_star(&mut $tokens, $span);
+        $crate::__private::push_star(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident -) => {
-        $crate::__rt::push_sub(&mut $tokens, $span);
+        $crate::__private::push_sub(&mut $tokens, $span);
     };
 
     ($tokens:ident $span:ident -=) => {
-        $crate::__rt::push_sub_eq(&mut $tokens, $span);
+        $crate::__private::push_sub_eq(&mut $tokens, $span);
+    };
+
+    ($tokens:ident $span:ident $ident:ident) => {
+        $crate::__private::push_ident(&mut $tokens, $span, stringify!($ident));
     };
 
     ($tokens:ident $span:ident $other:tt) => {
-        $crate::__rt::parse(&mut $tokens, $span, stringify!($other));
+        $crate::__private::parse(&mut $tokens, $span, stringify!($other));
     };
 }
diff --git a/src/runtime.rs b/src/runtime.rs
index 4a1c14c..bbdeb61 100644
--- a/src/runtime.rs
+++ b/src/runtime.rs
@@ -180,31 +180,23 @@ impl<T: ToTokens> ToTokens for RepInterp<T> {
     }
 }
 
-fn is_ident_start(c: u8) -> bool {
-    (b'a' <= c && c <= b'z') || (b'A' <= c && c <= b'Z') || c == b'_'
-}
-
-fn is_ident_continue(c: u8) -> bool {
-    (b'a' <= c && c <= b'z') || (b'A' <= c && c <= b'Z') || c == b'_' || (b'0' <= c && c <= b'9')
-}
-
-fn is_ident(token: &str) -> bool {
-    let mut iter = token.bytes();
-    let first_ok = iter.next().map(is_ident_start).unwrap_or(false);
-
-    first_ok && iter.all(is_ident_continue)
+pub fn parse(tokens: &mut TokenStream, span: Span, s: &str) {
+    let s: TokenStream = s.parse().expect("invalid token stream");
+    tokens.extend(s.into_iter().map(|mut t| {
+        t.set_span(span);
+        t
+    }));
 }
 
-pub fn parse(tokens: &mut TokenStream, span: Span, s: &str) {
-    if is_ident(s) {
-        // Fast path, since idents are the most common token.
-        tokens.append(Ident::new(s, span));
+pub fn push_ident(tokens: &mut TokenStream, span: Span, s: &str) {
+    // Optimization over `mk_ident`, as `s` is guaranteed to be a valid ident.
+    //
+    // FIXME: When `Ident::new_raw` becomes stable, this method should be
+    // updated to call it when available.
+    if s.starts_with("r#") {
+        parse(tokens, span, s);
     } else {
-        let s: TokenStream = s.parse().expect("invalid token stream");
-        tokens.extend(s.into_iter().map(|mut t| {
-            t.set_span(span);
-            t
-        }));
+        tokens.append(Ident::new(s, span));
     }
 }
 
@@ -293,9 +285,6 @@ push_punct!(push_sub_eq '-' '=');
 // although the input string was invalid, due to ignored characters such as
 // whitespace and comments. Instead, we always create a non-raw identifier
 // to validate that the string is OK, and only parse again if needed.
-//
-// The `is_ident` method defined above is insufficient for validation, as it
-// will reject non-ASCII identifiers.
 pub fn mk_ident(id: &str, span: Option<Span>) -> Ident {
     let span = span.unwrap_or_else(Span::call_site);
 
diff --git a/tests/test.rs b/tests/test.rs
index 957d470..be2b66b 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -160,7 +160,7 @@ fn test_char() {
     let tokens = quote! {
         #zero #pound #quote #apost #newline #heart
     };
-    let expected = "'\\u{0}' '#' '\"' '\\'' '\\n' '\\u{2764}'";
+    let expected = "'\\u{0}' '#' '\"' '\\'' '\\n' '\u{2764}'";
     assert_eq!(expected, tokens.to_string());
 }
 
@@ -427,3 +427,9 @@ fn test_star_after_repetition() {
     let expected = "f ( '0' ) ; f ( '1' ) ; * out = None ;";
     assert_eq!(expected, tokens.to_string());
 }
+
+#[test]
+fn test_quote_raw_id() {
+    let id = quote!(r#raw_id);
+    assert_eq!(id.to_string(), "r#raw_id");
+}