tests/ui/proc-macro/expr-stmt-nonterminal-tokens.stdout

   1 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = #[allow(warnings)] 0 ; 0 }, }
   2 PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = #[allow(warnings)] #[allow(warnings)] 0 ; 0 }, }
   3 PRINT-DERIVE INPUT (DEBUG): TokenStream [
   4     Ident {
   5         ident: "enum",
   6         span: #4 bytes(299..303),
   7     },
   8     Ident {
   9         ident: "E",
  10         span: #4 bytes(304..305),
  11     },
  12     Group {
  13         delimiter: Brace,
  14         stream: TokenStream [
  15             Ident {
  16                 ident: "V",
  17                 span: #4 bytes(320..321),
  18             },
  19             Punct {
  20                 ch: '=',
  21                 spacing: Alone,
  22                 span: #4 bytes(322..323),
  23             },
  24             Group {
  25                 delimiter: Brace,
  26                 stream: TokenStream [
  27                     Ident {
  28                         ident: "let",
  29                         span: #4 bytes(326..329),
  30                     },
  31                     Ident {
  32                         ident: "_",
  33                         span: #4 bytes(330..331),
  34                     },
  35                     Punct {
  36                         ch: '=',
  37                         spacing: Alone,
  38                         span: #4 bytes(332..333),
  39                     },
  40                     Group {
  41                         delimiter: None,
  42                         stream: TokenStream [
  43                             Punct {
  44                                 ch: '#',
  45                                 spacing: Alone,
  46                                 span: #0 bytes(541..542),
  47                             },
  48                             Group {
  49                                 delimiter: Bracket,
  50                                 stream: TokenStream [
  51                                     Ident {
  52                                         ident: "allow",
  53                                         span: #0 bytes(543..548),
  54                                     },
  55                                     Group {
  56                                         delimiter: Parenthesis,
  57                                         stream: TokenStream [
  58                                             Ident {
  59                                                 ident: "warnings",
  60                                                 span: #0 bytes(549..557),
  61                                             },
  62                                         ],
  63                                         span: #0 bytes(548..558),
  64                                     },
  65                                 ],
  66                                 span: #0 bytes(542..559),
  67                             },
  68                             Punct {
  69                                 ch: '#',
  70                                 spacing: Alone,
  71                                 span: #0 bytes(541..542),
  72                             },
  73                             Group {
  74                                 delimiter: Bracket,
  75                                 stream: TokenStream [
  76                                     Ident {
  77                                         ident: "allow",
  78                                         span: #0 bytes(543..548),
  79                                     },
  80                                     Group {
  81                                         delimiter: Parenthesis,
  82                                         stream: TokenStream [
  83                                             Ident {
  84                                                 ident: "warnings",
  85                                                 span: #0 bytes(549..557),
  86                                             },
  87                                         ],
  88                                         span: #0 bytes(548..558),
  89                                     },
  90                                 ],
  91                                 span: #0 bytes(542..559),
  92                             },
  93                             Literal {
  94                                 kind: Integer,
  95                                 symbol: "0",
  96                                 suffix: None,
  97                                 span: #0 bytes(560..561),
  98                             },
  99                         ],
 100                         span: #4 bytes(334..339),
 101                     },
 102                     Punct {
 103                         ch: ';',
 104                         spacing: Alone,
 105                         span: #4 bytes(339..340),
 106                     },
 107                     Literal {
 108                         kind: Integer,
 109                         symbol: "0",
 110                         suffix: None,
 111                         span: #4 bytes(341..342),
 112                     },
 113                 ],
 114                 span: #4 bytes(324..344),
 115             },
 116             Punct {
 117                 ch: ',',
 118                 spacing: Alone,
 119                 span: #4 bytes(344..345),
 120             },
 121         ],
 122         span: #4 bytes(306..355),
 123     },
 124 ]
 125 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { 0; } ; 0 }, }
 126 PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { 0 } ; 0 }, }
 127 PRINT-DERIVE INPUT (DEBUG): TokenStream [
 128     Ident {
 129         ident: "enum",
 130         span: #8 bytes(423..427),
 131     },
 132     Ident {
 133         ident: "E",
 134         span: #8 bytes(428..429),
 135     },
 136     Group {
 137         delimiter: Brace,
 138         stream: TokenStream [
 139             Ident {
 140                 ident: "V",
 141                 span: #8 bytes(444..445),
 142             },
 143             Punct {
 144                 ch: '=',
 145                 spacing: Alone,
 146                 span: #8 bytes(446..447),
 147             },
 148             Group {
 149                 delimiter: Brace,
 150                 stream: TokenStream [
 151                     Ident {
 152                         ident: "let",
 153                         span: #8 bytes(450..453),
 154                     },
 155                     Ident {
 156                         ident: "_",
 157                         span: #8 bytes(454..455),
 158                     },
 159                     Punct {
 160                         ch: '=',
 161                         spacing: Alone,
 162                         span: #8 bytes(456..457),
 163                     },
 164                     Group {
 165                         delimiter: Brace,
 166                         stream: TokenStream [
 167                             Group {
 168                                 delimiter: None,
 169                                 stream: TokenStream [
 170                                     Literal {
 171                                         kind: Integer,
 172                                         symbol: "0",
 173                                         suffix: None,
 174                                         span: #0 bytes(578..579),
 175                                     },
 176                                 ],
 177                                 span: #8 bytes(460..465),
 178                             },
 179                         ],
 180                         span: #8 bytes(458..467),
 181                     },
 182                     Punct {
 183                         ch: ';',
 184                         spacing: Alone,
 185                         span: #8 bytes(467..468),
 186                     },
 187                     Literal {
 188                         kind: Integer,
 189                         symbol: "0",
 190                         suffix: None,
 191                         span: #8 bytes(469..470),
 192                     },
 193                 ],
 194                 span: #8 bytes(448..472),
 195             },
 196             Punct {
 197                 ch: ',',
 198                 spacing: Alone,
 199                 span: #8 bytes(472..473),
 200             },
 201         ],
 202         span: #8 bytes(430..483),
 203     },
 204 ]
 205 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { {} } ; 0 }, }
 206 PRINT-DERIVE INPUT (DEBUG): TokenStream [
 207     Ident {
 208         ident: "enum",
 209         span: #12 bytes(423..427),
 210     },
 211     Ident {
 212         ident: "E",
 213         span: #12 bytes(428..429),
 214     },
 215     Group {
 216         delimiter: Brace,
 217         stream: TokenStream [
 218             Ident {
 219                 ident: "V",
 220                 span: #12 bytes(444..445),
 221             },
 222             Punct {
 223                 ch: '=',
 224                 spacing: Alone,
 225                 span: #12 bytes(446..447),
 226             },
 227             Group {
 228                 delimiter: Brace,
 229                 stream: TokenStream [
 230                     Ident {
 231                         ident: "let",
 232                         span: #12 bytes(450..453),
 233                     },
 234                     Ident {
 235                         ident: "_",
 236                         span: #12 bytes(454..455),
 237                     },
 238                     Punct {
 239                         ch: '=',
 240                         spacing: Alone,
 241                         span: #12 bytes(456..457),
 242                     },
 243                     Group {
 244                         delimiter: Brace,
 245                         stream: TokenStream [
 246                             Group {
 247                                 delimiter: None,
 248                                 stream: TokenStream [
 249                                     Group {
 250                                         delimiter: Brace,
 251                                         stream: TokenStream [],
 252                                         span: #0 bytes(596..598),
 253                                     },
 254                                 ],
 255                                 span: #12 bytes(460..465),
 256                             },
 257                         ],
 258                         span: #12 bytes(458..467),
 259                     },
 260                     Punct {
 261                         ch: ';',
 262                         spacing: Alone,
 263                         span: #12 bytes(467..468),
 264                     },
 265                     Literal {
 266                         kind: Integer,
 267                         symbol: "0",
 268                         suffix: None,
 269                         span: #12 bytes(469..470),
 270                     },
 271                 ],
 272                 span: #12 bytes(448..472),
 273             },
 274             Punct {
 275                 ch: ',',
 276                 spacing: Alone,
 277                 span: #12 bytes(472..473),
 278             },
 279         ],
 280         span: #12 bytes(430..483),
 281     },
 282 ]
 283 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { PATH; } ; 0 }, }
 284 PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { PATH } ; 0 }, }
 285 PRINT-DERIVE INPUT (DEBUG): TokenStream [
 286     Ident {
 287         ident: "enum",
 288         span: #16 bytes(423..427),
 289     },
 290     Ident {
 291         ident: "E",
 292         span: #16 bytes(428..429),
 293     },
 294     Group {
 295         delimiter: Brace,
 296         stream: TokenStream [
 297             Ident {
 298                 ident: "V",
 299                 span: #16 bytes(444..445),
 300             },
 301             Punct {
 302                 ch: '=',
 303                 spacing: Alone,
 304                 span: #16 bytes(446..447),
 305             },
 306             Group {
 307                 delimiter: Brace,
 308                 stream: TokenStream [
 309                     Ident {
 310                         ident: "let",
 311                         span: #16 bytes(450..453),
 312                     },
 313                     Ident {
 314                         ident: "_",
 315                         span: #16 bytes(454..455),
 316                     },
 317                     Punct {
 318                         ch: '=',
 319                         spacing: Alone,
 320                         span: #16 bytes(456..457),
 321                     },
 322                     Group {
 323                         delimiter: Brace,
 324                         stream: TokenStream [
 325                             Group {
 326                                 delimiter: None,
 327                                 stream: TokenStream [
 328                                     Ident {
 329                                         ident: "PATH",
 330                                         span: #0 bytes(615..619),
 331                                     },
 332                                 ],
 333                                 span: #16 bytes(460..465),
 334                             },
 335                         ],
 336                         span: #16 bytes(458..467),
 337                     },
 338                     Punct {
 339                         ch: ';',
 340                         spacing: Alone,
 341                         span: #16 bytes(467..468),
 342                     },
 343                     Literal {
 344                         kind: Integer,
 345                         symbol: "0",
 346                         suffix: None,
 347                         span: #16 bytes(469..470),
 348                     },
 349                 ],
 350                 span: #16 bytes(448..472),
 351             },
 352             Punct {
 353                 ch: ',',
 354                 spacing: Alone,
 355                 span: #16 bytes(472..473),
 356             },
 357         ],
 358         span: #16 bytes(430..483),
 359     },
 360 ]
 361 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { 0 + 1; } ; 0 }, }
 362 PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { 0 + 1 } ; 0 }, }
 363 PRINT-DERIVE INPUT (DEBUG): TokenStream [
 364     Ident {
 365         ident: "enum",
 366         span: #20 bytes(423..427),
 367     },
 368     Ident {
 369         ident: "E",
 370         span: #20 bytes(428..429),
 371     },
 372     Group {
 373         delimiter: Brace,
 374         stream: TokenStream [
 375             Ident {
 376                 ident: "V",
 377                 span: #20 bytes(444..445),
 378             },
 379             Punct {
 380                 ch: '=',
 381                 spacing: Alone,
 382                 span: #20 bytes(446..447),
 383             },
 384             Group {
 385                 delimiter: Brace,
 386                 stream: TokenStream [
 387                     Ident {
 388                         ident: "let",
 389                         span: #20 bytes(450..453),
 390                     },
 391                     Ident {
 392                         ident: "_",
 393                         span: #20 bytes(454..455),
 394                     },
 395                     Punct {
 396                         ch: '=',
 397                         spacing: Alone,
 398                         span: #20 bytes(456..457),
 399                     },
 400                     Group {
 401                         delimiter: Brace,
 402                         stream: TokenStream [
 403                             Group {
 404                                 delimiter: None,
 405                                 stream: TokenStream [
 406                                     Literal {
 407                                         kind: Integer,
 408                                         symbol: "0",
 409                                         suffix: None,
 410                                         span: #0 bytes(636..637),
 411                                     },
 412                                     Punct {
 413                                         ch: '+',
 414                                         spacing: Alone,
 415                                         span: #0 bytes(638..639),
 416                                     },
 417                                     Literal {
 418                                         kind: Integer,
 419                                         symbol: "1",
 420                                         suffix: None,
 421                                         span: #0 bytes(640..641),
 422                                     },
 423                                 ],
 424                                 span: #20 bytes(460..465),
 425                             },
 426                         ],
 427                         span: #20 bytes(458..467),
 428                     },
 429                     Punct {
 430                         ch: ';',
 431                         spacing: Alone,
 432                         span: #20 bytes(467..468),
 433                     },
 434                     Literal {
 435                         kind: Integer,
 436                         symbol: "0",
 437                         suffix: None,
 438                         span: #20 bytes(469..470),
 439                     },
 440                 ],
 441                 span: #20 bytes(448..472),
 442             },
 443             Punct {
 444                 ch: ',',
 445                 spacing: Alone,
 446                 span: #20 bytes(472..473),
 447             },
 448         ],
 449         span: #20 bytes(430..483),
 450     },
 451 ]
 452 PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { PATH + 1; } ; 0 }, }
 453 PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { PATH + 1 } ; 0 }, }
 454 PRINT-DERIVE INPUT (DEBUG): TokenStream [
 455     Ident {
 456         ident: "enum",
 457         span: #24 bytes(423..427),
 458     },
 459     Ident {
 460         ident: "E",
 461         span: #24 bytes(428..429),
 462     },
 463     Group {
 464         delimiter: Brace,
 465         stream: TokenStream [
 466             Ident {
 467                 ident: "V",
 468                 span: #24 bytes(444..445),
 469             },
 470             Punct {
 471                 ch: '=',
 472                 spacing: Alone,
 473                 span: #24 bytes(446..447),
 474             },
 475             Group {
 476                 delimiter: Brace,
 477                 stream: TokenStream [
 478                     Ident {
 479                         ident: "let",
 480                         span: #24 bytes(450..453),
 481                     },
 482                     Ident {
 483                         ident: "_",
 484                         span: #24 bytes(454..455),
 485                     },
 486                     Punct {
 487                         ch: '=',
 488                         spacing: Alone,
 489                         span: #24 bytes(456..457),
 490                     },
 491                     Group {
 492                         delimiter: Brace,
 493                         stream: TokenStream [
 494                             Group {
 495                                 delimiter: None,
 496                                 stream: TokenStream [
 497                                     Ident {
 498                                         ident: "PATH",
 499                                         span: #0 bytes(658..662),
 500                                     },
 501                                     Punct {
 502                                         ch: '+',
 503                                         spacing: Alone,
 504                                         span: #0 bytes(663..664),
 505                                     },
 506                                     Literal {
 507                                         kind: Integer,
 508                                         symbol: "1",
 509                                         suffix: None,
 510                                         span: #0 bytes(665..666),
 511                                     },
 512                                 ],
 513                                 span: #24 bytes(460..465),
 514                             },
 515                         ],
 516                         span: #24 bytes(458..467),
 517                     },
 518                     Punct {
 519                         ch: ';',
 520                         spacing: Alone,
 521                         span: #24 bytes(467..468),
 522                     },
 523                     Literal {
 524                         kind: Integer,
 525                         symbol: "0",
 526                         suffix: None,
 527                         span: #24 bytes(469..470),
 528                     },
 529                 ],
 530                 span: #24 bytes(448..472),
 531             },
 532             Punct {
 533                 ch: ',',
 534                 spacing: Alone,
 535                 span: #24 bytes(472..473),
 536             },
 537         ],
 538         span: #24 bytes(430..483),
 539     },
 540 ]