David Tolnay | a13d142 | 2018-03-31 21:27:48 +0200 | [diff] [blame] | 1 | use std::str::{self, FromStr}; |
Alex Crichton | 8c03033 | 2018-01-16 08:07:36 -0800 | [diff] [blame] | 2 | |
David Tolnay | 3d9d6ad | 2018-05-18 10:51:55 -0700 | [diff] [blame] | 3 | use proc_macro2::{Ident, Literal, Spacing, Span, TokenStream, TokenTree}; |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 4 | |
| 5 | #[test] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 6 | fn idents() { |
David Tolnay | 3d9d6ad | 2018-05-18 10:51:55 -0700 | [diff] [blame] | 7 | assert_eq!( |
| 8 | Ident::new("String", Span::call_site()).to_string(), |
| 9 | "String" |
| 10 | ); |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 11 | assert_eq!(Ident::new("fn", Span::call_site()).to_string(), "fn"); |
| 12 | assert_eq!(Ident::new("_", Span::call_site()).to_string(), "_"); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 13 | } |
| 14 | |
| 15 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 16 | #[cfg(procmacro2_semver_exempt)] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 17 | fn raw_idents() { |
David Tolnay | 48ea504 | 2018-04-23 19:17:35 -0700 | [diff] [blame] | 18 | assert_eq!( |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 19 | Ident::new_raw("String", Span::call_site()).to_string(), |
David Tolnay | 48ea504 | 2018-04-23 19:17:35 -0700 | [diff] [blame] | 20 | "r#String" |
| 21 | ); |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 22 | assert_eq!(Ident::new_raw("fn", Span::call_site()).to_string(), "r#fn"); |
| 23 | assert_eq!(Ident::new_raw("_", Span::call_site()).to_string(), "r#_"); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 24 | } |
| 25 | |
| 26 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 27 | #[should_panic(expected = "Ident is not allowed to be empty; use Option<Ident>")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 28 | fn ident_empty() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 29 | Ident::new("", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 30 | } |
| 31 | |
| 32 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 33 | #[should_panic(expected = "Ident cannot be a number; use Literal instead")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 34 | fn ident_number() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 35 | Ident::new("255", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 36 | } |
| 37 | |
| 38 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 39 | #[should_panic(expected = "\"a#\" is not a valid Ident")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 40 | fn ident_invalid() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 41 | Ident::new("a#", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 42 | } |
| 43 | |
| 44 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 45 | #[should_panic(expected = "not a valid Ident")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 46 | fn raw_ident_empty() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 47 | Ident::new("r#", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 48 | } |
| 49 | |
| 50 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 51 | #[should_panic(expected = "not a valid Ident")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 52 | fn raw_ident_number() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 53 | Ident::new("r#255", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 57 | #[should_panic(expected = "\"r#a#\" is not a valid Ident")] |
David Tolnay | 637eef4 | 2019-04-20 13:36:18 -0700 | [diff] [blame] | 58 | fn raw_ident_invalid() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 59 | Ident::new("r#a#", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 63 | #[should_panic(expected = "not a valid Ident")] |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 64 | fn lifetime_empty() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 65 | Ident::new("'", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 69 | #[should_panic(expected = "not a valid Ident")] |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 70 | fn lifetime_number() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 71 | Ident::new("'255", Span::call_site()); |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | #[test] |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 75 | #[should_panic(expected = r#""\'a#" is not a valid Ident"#)] |
David Tolnay | 489c642 | 2018-04-07 08:37:28 -0700 | [diff] [blame] | 76 | fn lifetime_invalid() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 77 | Ident::new("'a#", Span::call_site()); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 78 | } |
| 79 | |
| 80 | #[test] |
David Tolnay | e4482f4 | 2019-04-22 16:15:14 -0700 | [diff] [blame] | 81 | fn literal_string() { |
Alex Crichton | 1a7f762 | 2017-07-05 17:47:15 -0700 | [diff] [blame] | 82 | assert_eq!(Literal::string("foo").to_string(), "\"foo\""); |
| 83 | assert_eq!(Literal::string("\"").to_string(), "\"\\\"\""); |
David Tolnay | e4482f4 | 2019-04-22 16:15:14 -0700 | [diff] [blame] | 84 | assert_eq!(Literal::string("didn't").to_string(), "\"didn't\""); |
| 85 | } |
| 86 | |
| 87 | #[test] |
| 88 | fn literal_character() { |
| 89 | assert_eq!(Literal::character('x').to_string(), "'x'"); |
| 90 | assert_eq!(Literal::character('\'').to_string(), "'\\''"); |
| 91 | assert_eq!(Literal::character('"').to_string(), "'\"'"); |
| 92 | } |
| 93 | |
| 94 | #[test] |
| 95 | fn literal_float() { |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 96 | assert_eq!(Literal::f32_unsuffixed(10.0).to_string(), "10.0"); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | #[test] |
| 100 | fn roundtrip() { |
| 101 | fn roundtrip(p: &str) { |
| 102 | println!("parse: {}", p); |
| 103 | let s = p.parse::<TokenStream>().unwrap().to_string(); |
| 104 | println!("first: {}", s); |
| 105 | let s2 = s.to_string().parse::<TokenStream>().unwrap().to_string(); |
| 106 | assert_eq!(s, s2); |
| 107 | } |
| 108 | roundtrip("a"); |
| 109 | roundtrip("<<"); |
| 110 | roundtrip("<<="); |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 111 | roundtrip( |
| 112 | " |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 113 | 1 |
| 114 | 1.0 |
| 115 | 1f32 |
| 116 | 2f64 |
| 117 | 1usize |
| 118 | 4isize |
| 119 | 4e10 |
| 120 | 1_000 |
| 121 | 1_0i32 |
| 122 | 8u8 |
| 123 | 9 |
| 124 | 0 |
| 125 | 0xffffffffffffffffffffffffffffffff |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 126 | ", |
| 127 | ); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 128 | roundtrip("'a"); |
Alex Crichton | f5479a9 | 2018-05-17 10:56:26 -0700 | [diff] [blame] | 129 | roundtrip("'_"); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 130 | roundtrip("'static"); |
David Tolnay | 8d10934 | 2017-12-25 18:24:45 -0500 | [diff] [blame] | 131 | roundtrip("'\\u{10__FFFF}'"); |
| 132 | roundtrip("\"\\u{10_F0FF__}foo\\u{1_0_0_0__}\""); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | #[test] |
| 136 | fn fail() { |
| 137 | fn fail(p: &str) { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 138 | if let Ok(s) = p.parse::<TokenStream>() { |
| 139 | panic!("should have failed to parse: {}\n{:#?}", p, s); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 140 | } |
| 141 | } |
| 142 | fail("1x"); |
| 143 | fail("1u80"); |
| 144 | fail("1f320"); |
| 145 | fail("' static"); |
David Tolnay | a13d142 | 2018-03-31 21:27:48 +0200 | [diff] [blame] | 146 | fail("r#1"); |
| 147 | fail("r#_"); |
David Tolnay | e580685 | 2017-06-01 12:49:20 -0700 | [diff] [blame] | 148 | } |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 149 | |
David Tolnay | 3b1f7d2 | 2019-01-28 12:22:11 -0800 | [diff] [blame] | 150 | #[cfg(span_locations)] |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 151 | #[test] |
| 152 | fn span_test() { |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 153 | use proc_macro2::TokenTree; |
| 154 | |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 155 | fn check_spans(p: &str, mut lines: &[(usize, usize, usize, usize)]) { |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 156 | let ts = p.parse::<TokenStream>().unwrap(); |
| 157 | check_spans_internal(ts, &mut lines); |
| 158 | } |
| 159 | |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 160 | fn check_spans_internal(ts: TokenStream, lines: &mut &[(usize, usize, usize, usize)]) { |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 161 | for i in ts { |
| 162 | if let Some((&(sline, scol, eline, ecol), rest)) = lines.split_first() { |
| 163 | *lines = rest; |
| 164 | |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 165 | let start = i.span().start(); |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 166 | assert_eq!(start.line, sline, "sline did not match for {}", i); |
| 167 | assert_eq!(start.column, scol, "scol did not match for {}", i); |
| 168 | |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 169 | let end = i.span().end(); |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 170 | assert_eq!(end.line, eline, "eline did not match for {}", i); |
| 171 | assert_eq!(end.column, ecol, "ecol did not match for {}", i); |
| 172 | |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 173 | match i { |
| 174 | TokenTree::Group(ref g) => { |
| 175 | check_spans_internal(g.stream().clone(), lines); |
| 176 | } |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 177 | _ => {} |
| 178 | } |
| 179 | } |
| 180 | } |
| 181 | } |
| 182 | |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 183 | check_spans( |
| 184 | "\ |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 185 | /// This is a document comment |
| 186 | testing 123 |
| 187 | { |
| 188 | testing 234 |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 189 | }", |
| 190 | &[ |
Alex Crichton | 1eb96a0 | 2018-04-04 13:07:35 -0700 | [diff] [blame] | 191 | (1, 0, 1, 30), // # |
| 192 | (1, 0, 1, 30), // [ ... ] |
| 193 | (1, 0, 1, 30), // doc |
| 194 | (1, 0, 1, 30), // = |
| 195 | (1, 0, 1, 30), // "This is..." |
| 196 | (2, 0, 2, 7), // testing |
| 197 | (2, 8, 2, 11), // 123 |
| 198 | (3, 0, 5, 1), // { ... } |
| 199 | (4, 2, 4, 9), // testing |
| 200 | (4, 10, 4, 13), // 234 |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 201 | ], |
| 202 | ); |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 203 | } |
| 204 | |
David Tolnay | 1ebe397 | 2018-01-02 20:14:20 -0800 | [diff] [blame] | 205 | #[cfg(procmacro2_semver_exempt)] |
David Tolnay | 17eb070 | 2019-01-05 12:23:17 -0800 | [diff] [blame] | 206 | #[cfg(not(nightly))] |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 207 | #[test] |
| 208 | fn default_span() { |
| 209 | let start = Span::call_site().start(); |
| 210 | assert_eq!(start.line, 1); |
| 211 | assert_eq!(start.column, 0); |
| 212 | let end = Span::call_site().end(); |
| 213 | assert_eq!(end.line, 1); |
| 214 | assert_eq!(end.column, 0); |
| 215 | let source_file = Span::call_site().source_file(); |
David Tolnay | 9cd3b4c | 2018-11-11 16:47:32 -0800 | [diff] [blame] | 216 | assert_eq!(source_file.path().to_string_lossy(), "<unspecified>"); |
Nika Layzell | f8d5f21 | 2017-12-11 14:07:02 -0500 | [diff] [blame] | 217 | assert!(!source_file.is_real()); |
| 218 | } |
| 219 | |
David Tolnay | 1ebe397 | 2018-01-02 20:14:20 -0800 | [diff] [blame] | 220 | #[cfg(procmacro2_semver_exempt)] |
Nika Layzell | ddea156 | 2017-12-11 14:25:35 -0500 | [diff] [blame] | 221 | #[test] |
| 222 | fn span_join() { |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 223 | let source1 = "aaa\nbbb" |
| 224 | .parse::<TokenStream>() |
| 225 | .unwrap() |
| 226 | .into_iter() |
| 227 | .collect::<Vec<_>>(); |
| 228 | let source2 = "ccc\nddd" |
| 229 | .parse::<TokenStream>() |
| 230 | .unwrap() |
| 231 | .into_iter() |
| 232 | .collect::<Vec<_>>(); |
Nika Layzell | ddea156 | 2017-12-11 14:25:35 -0500 | [diff] [blame] | 233 | |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 234 | assert!(source1[0].span().source_file() != source2[0].span().source_file()); |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 235 | assert_eq!( |
| 236 | source1[0].span().source_file(), |
| 237 | source1[1].span().source_file() |
| 238 | ); |
Nika Layzell | ddea156 | 2017-12-11 14:25:35 -0500 | [diff] [blame] | 239 | |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 240 | let joined1 = source1[0].span().join(source1[1].span()); |
| 241 | let joined2 = source1[0].span().join(source2[0].span()); |
Nika Layzell | ddea156 | 2017-12-11 14:25:35 -0500 | [diff] [blame] | 242 | assert!(joined1.is_some()); |
| 243 | assert!(joined2.is_none()); |
| 244 | |
| 245 | let start = joined1.unwrap().start(); |
| 246 | let end = joined1.unwrap().end(); |
| 247 | assert_eq!(start.line, 1); |
| 248 | assert_eq!(start.column, 0); |
| 249 | assert_eq!(end.line, 2); |
| 250 | assert_eq!(end.column, 3); |
| 251 | |
David Tolnay | b28f38a | 2018-03-31 22:02:29 +0200 | [diff] [blame] | 252 | assert_eq!( |
| 253 | joined1.unwrap().source_file(), |
| 254 | source1[0].span().source_file() |
| 255 | ); |
Nika Layzell | ddea156 | 2017-12-11 14:25:35 -0500 | [diff] [blame] | 256 | } |
Alex Crichton | 8c03033 | 2018-01-16 08:07:36 -0800 | [diff] [blame] | 257 | |
| 258 | #[test] |
| 259 | fn no_panic() { |
| 260 | let s = str::from_utf8(b"b\'\xc2\x86 \x00\x00\x00^\"").unwrap(); |
| 261 | assert!(s.parse::<proc_macro2::TokenStream>().is_err()); |
| 262 | } |
| 263 | |
Alex Crichton | f7df57c | 2018-01-21 21:05:11 -0800 | [diff] [blame] | 264 | #[test] |
David Tolnay | 639e4ba | 2018-03-31 21:10:55 +0200 | [diff] [blame] | 265 | fn tricky_doc_comment() { |
Alex Crichton | f7df57c | 2018-01-21 21:05:11 -0800 | [diff] [blame] | 266 | let stream = "/**/".parse::<proc_macro2::TokenStream>().unwrap(); |
| 267 | let tokens = stream.into_iter().collect::<Vec<_>>(); |
| 268 | assert!(tokens.is_empty(), "not empty -- {:?}", tokens); |
Alex Crichton | d7904e5 | 2018-01-23 11:08:45 -0800 | [diff] [blame] | 269 | |
| 270 | let stream = "/// doc".parse::<proc_macro2::TokenStream>().unwrap(); |
| 271 | let tokens = stream.into_iter().collect::<Vec<_>>(); |
Alex Crichton | 1eb96a0 | 2018-04-04 13:07:35 -0700 | [diff] [blame] | 272 | assert!(tokens.len() == 2, "not length 2 -- {:?}", tokens); |
Alex Crichton | af5bad4 | 2018-03-27 14:45:10 -0700 | [diff] [blame] | 273 | match tokens[0] { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 274 | proc_macro2::TokenTree::Punct(ref tt) => assert_eq!(tt.as_char(), '#'), |
Alex Crichton | d7904e5 | 2018-01-23 11:08:45 -0800 | [diff] [blame] | 275 | _ => panic!("wrong token {:?}", tokens[0]), |
| 276 | } |
Alex Crichton | 1eb96a0 | 2018-04-04 13:07:35 -0700 | [diff] [blame] | 277 | let mut tokens = match tokens[1] { |
| 278 | proc_macro2::TokenTree::Group(ref tt) => { |
| 279 | assert_eq!(tt.delimiter(), proc_macro2::Delimiter::Bracket); |
| 280 | tt.stream().into_iter() |
| 281 | } |
| 282 | _ => panic!("wrong token {:?}", tokens[0]), |
| 283 | }; |
| 284 | |
| 285 | match tokens.next().unwrap() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 286 | proc_macro2::TokenTree::Ident(ref tt) => assert_eq!(tt.to_string(), "doc"), |
Alex Crichton | 1eb96a0 | 2018-04-04 13:07:35 -0700 | [diff] [blame] | 287 | t => panic!("wrong token {:?}", t), |
| 288 | } |
| 289 | match tokens.next().unwrap() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 290 | proc_macro2::TokenTree::Punct(ref tt) => assert_eq!(tt.as_char(), '='), |
Alex Crichton | 1eb96a0 | 2018-04-04 13:07:35 -0700 | [diff] [blame] | 291 | t => panic!("wrong token {:?}", t), |
| 292 | } |
| 293 | match tokens.next().unwrap() { |
| 294 | proc_macro2::TokenTree::Literal(ref tt) => { |
| 295 | assert_eq!(tt.to_string(), "\" doc\""); |
| 296 | } |
| 297 | t => panic!("wrong token {:?}", t), |
| 298 | } |
| 299 | assert!(tokens.next().is_none()); |
| 300 | |
| 301 | let stream = "//! doc".parse::<proc_macro2::TokenStream>().unwrap(); |
| 302 | let tokens = stream.into_iter().collect::<Vec<_>>(); |
| 303 | assert!(tokens.len() == 3, "not length 3 -- {:?}", tokens); |
Alex Crichton | f7df57c | 2018-01-21 21:05:11 -0800 | [diff] [blame] | 304 | } |
| 305 | |
David Tolnay | a13d142 | 2018-03-31 21:27:48 +0200 | [diff] [blame] | 306 | #[test] |
David Tolnay | 3a592ad | 2018-04-22 21:20:24 -0700 | [diff] [blame] | 307 | fn op_before_comment() { |
| 308 | let mut tts = TokenStream::from_str("~// comment").unwrap().into_iter(); |
| 309 | match tts.next().unwrap() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 310 | TokenTree::Punct(tt) => { |
| 311 | assert_eq!(tt.as_char(), '~'); |
David Tolnay | 3a592ad | 2018-04-22 21:20:24 -0700 | [diff] [blame] | 312 | assert_eq!(tt.spacing(), Spacing::Alone); |
| 313 | } |
| 314 | wrong => panic!("wrong token {:?}", wrong), |
| 315 | } |
| 316 | } |
| 317 | |
| 318 | #[test] |
David Tolnay | a13d142 | 2018-03-31 21:27:48 +0200 | [diff] [blame] | 319 | fn raw_identifier() { |
| 320 | let mut tts = TokenStream::from_str("r#dyn").unwrap().into_iter(); |
| 321 | match tts.next().unwrap() { |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 322 | TokenTree::Ident(raw) => assert_eq!("r#dyn", raw.to_string()), |
David Tolnay | a13d142 | 2018-03-31 21:27:48 +0200 | [diff] [blame] | 323 | wrong => panic!("wrong token {:?}", wrong), |
| 324 | } |
| 325 | assert!(tts.next().is_none()); |
| 326 | } |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 327 | |
| 328 | #[test] |
David Tolnay | d8fcdb8 | 2018-06-02 15:43:53 -0700 | [diff] [blame] | 329 | fn test_debug_ident() { |
| 330 | let ident = Ident::new("proc_macro", Span::call_site()); |
| 331 | |
| 332 | #[cfg(not(procmacro2_semver_exempt))] |
| 333 | let expected = "Ident(proc_macro)"; |
| 334 | |
| 335 | #[cfg(procmacro2_semver_exempt)] |
| 336 | let expected = "Ident { sym: proc_macro, span: bytes(0..0) }"; |
| 337 | |
| 338 | assert_eq!(expected, format!("{:?}", ident)); |
| 339 | } |
| 340 | |
| 341 | #[test] |
| 342 | fn test_debug_tokenstream() { |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 343 | let tts = TokenStream::from_str("[a + 1]").unwrap(); |
| 344 | |
| 345 | #[cfg(not(procmacro2_semver_exempt))] |
| 346 | let expected = "\ |
| 347 | TokenStream [ |
| 348 | Group { |
| 349 | delimiter: Bracket, |
| 350 | stream: TokenStream [ |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 351 | Ident { |
David Tolnay | 5a2f730 | 2019-04-10 15:57:36 -0700 | [diff] [blame] | 352 | sym: a, |
| 353 | }, |
| 354 | Punct { |
| 355 | op: '+', |
| 356 | spacing: Alone, |
| 357 | }, |
| 358 | Literal { |
| 359 | lit: 1, |
| 360 | }, |
| 361 | ], |
| 362 | }, |
| 363 | ]\ |
| 364 | "; |
| 365 | |
| 366 | #[cfg(not(procmacro2_semver_exempt))] |
| 367 | let expected_before_trailing_commas = "\ |
| 368 | TokenStream [ |
| 369 | Group { |
| 370 | delimiter: Bracket, |
| 371 | stream: TokenStream [ |
| 372 | Ident { |
David Tolnay | d8fcdb8 | 2018-06-02 15:43:53 -0700 | [diff] [blame] | 373 | sym: a |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 374 | }, |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 375 | Punct { |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 376 | op: '+', |
| 377 | spacing: Alone |
| 378 | }, |
| 379 | Literal { |
| 380 | lit: 1 |
| 381 | } |
| 382 | ] |
| 383 | } |
| 384 | ]\ |
| 385 | "; |
| 386 | |
| 387 | #[cfg(procmacro2_semver_exempt)] |
| 388 | let expected = "\ |
| 389 | TokenStream [ |
| 390 | Group { |
| 391 | delimiter: Bracket, |
| 392 | stream: TokenStream [ |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 393 | Ident { |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 394 | sym: a, |
David Tolnay | 5a2f730 | 2019-04-10 15:57:36 -0700 | [diff] [blame] | 395 | span: bytes(2..3), |
| 396 | }, |
| 397 | Punct { |
| 398 | op: '+', |
| 399 | spacing: Alone, |
| 400 | span: bytes(4..5), |
| 401 | }, |
| 402 | Literal { |
| 403 | lit: 1, |
| 404 | span: bytes(6..7), |
| 405 | }, |
| 406 | ], |
| 407 | span: bytes(1..8), |
| 408 | }, |
| 409 | ]\ |
| 410 | "; |
| 411 | |
| 412 | #[cfg(procmacro2_semver_exempt)] |
| 413 | let expected_before_trailing_commas = "\ |
| 414 | TokenStream [ |
| 415 | Group { |
| 416 | delimiter: Bracket, |
| 417 | stream: TokenStream [ |
| 418 | Ident { |
| 419 | sym: a, |
David Tolnay | d8fcdb8 | 2018-06-02 15:43:53 -0700 | [diff] [blame] | 420 | span: bytes(2..3) |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 421 | }, |
Alex Crichton | f388843 | 2018-05-16 09:11:05 -0700 | [diff] [blame] | 422 | Punct { |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 423 | op: '+', |
| 424 | spacing: Alone, |
| 425 | span: bytes(4..5) |
| 426 | }, |
| 427 | Literal { |
| 428 | lit: 1, |
| 429 | span: bytes(6..7) |
| 430 | } |
| 431 | ], |
| 432 | span: bytes(1..8) |
| 433 | } |
| 434 | ]\ |
| 435 | "; |
| 436 | |
David Tolnay | 5a2f730 | 2019-04-10 15:57:36 -0700 | [diff] [blame] | 437 | let actual = format!("{:#?}", tts); |
| 438 | if actual.ends_with(",\n]") { |
| 439 | assert_eq!(expected, actual); |
| 440 | } else { |
| 441 | assert_eq!(expected_before_trailing_commas, actual); |
| 442 | } |
David Tolnay | 034205f | 2018-04-22 16:45:28 -0700 | [diff] [blame] | 443 | } |
Árpád Goretity | 4f74b68 | 2018-07-14 00:47:51 +0200 | [diff] [blame] | 444 | |
| 445 | #[test] |
| 446 | fn default_tokenstream_is_empty() { |
| 447 | let default_token_stream: TokenStream = Default::default(); |
| 448 | |
| 449 | assert!(default_token_stream.is_empty()); |
| 450 | } |