fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
18.5 KiB540 linesraw
1PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = #[allow(warnings)] 0 ; 0 }, }
2PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = #[allow(warnings)] #[allow(warnings)] 0 ; 0 }, }
3PRINT-DERIVE INPUT (DEBUG): TokenStream [
4    Ident {
5        ident: "enum",
6        span: #3 bytes(299..303),
7    },
8    Ident {
9        ident: "E",
10        span: #3 bytes(304..305),
11    },
12    Group {
13        delimiter: Brace,
14        stream: TokenStream [
15            Ident {
16                ident: "V",
17                span: #3 bytes(320..321),
18            },
19            Punct {
20                ch: '=',
21                spacing: Alone,
22                span: #3 bytes(322..323),
23            },
24            Group {
25                delimiter: Brace,
26                stream: TokenStream [
27                    Ident {
28                        ident: "let",
29                        span: #3 bytes(326..329),
30                    },
31                    Ident {
32                        ident: "_",
33                        span: #3 bytes(330..331),
34                    },
35                    Punct {
36                        ch: '=',
37                        spacing: Alone,
38                        span: #3 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: #3 bytes(334..339),
101                    },
102                    Punct {
103                        ch: ';',
104                        spacing: Alone,
105                        span: #3 bytes(339..340),
106                    },
107                    Literal {
108                        kind: Integer,
109                        symbol: "0",
110                        suffix: None,
111                        span: #3 bytes(341..342),
112                    },
113                ],
114                span: #3 bytes(324..344),
115            },
116            Punct {
117                ch: ',',
118                spacing: Alone,
119                span: #3 bytes(344..345),
120            },
121        ],
122        span: #3 bytes(306..355),
123    },
124]
125PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { 0; } ; 0 }, }
126PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { 0 } ; 0 }, }
127PRINT-DERIVE INPUT (DEBUG): TokenStream [
128    Ident {
129        ident: "enum",
130        span: #7 bytes(423..427),
131    },
132    Ident {
133        ident: "E",
134        span: #7 bytes(428..429),
135    },
136    Group {
137        delimiter: Brace,
138        stream: TokenStream [
139            Ident {
140                ident: "V",
141                span: #7 bytes(444..445),
142            },
143            Punct {
144                ch: '=',
145                spacing: Alone,
146                span: #7 bytes(446..447),
147            },
148            Group {
149                delimiter: Brace,
150                stream: TokenStream [
151                    Ident {
152                        ident: "let",
153                        span: #7 bytes(450..453),
154                    },
155                    Ident {
156                        ident: "_",
157                        span: #7 bytes(454..455),
158                    },
159                    Punct {
160                        ch: '=',
161                        spacing: Alone,
162                        span: #7 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: #7 bytes(460..465),
178                            },
179                        ],
180                        span: #7 bytes(458..467),
181                    },
182                    Punct {
183                        ch: ';',
184                        spacing: Alone,
185                        span: #7 bytes(467..468),
186                    },
187                    Literal {
188                        kind: Integer,
189                        symbol: "0",
190                        suffix: None,
191                        span: #7 bytes(469..470),
192                    },
193                ],
194                span: #7 bytes(448..472),
195            },
196            Punct {
197                ch: ',',
198                spacing: Alone,
199                span: #7 bytes(472..473),
200            },
201        ],
202        span: #7 bytes(430..483),
203    },
204]
205PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { {} } ; 0 }, }
206PRINT-DERIVE INPUT (DEBUG): TokenStream [
207    Ident {
208        ident: "enum",
209        span: #11 bytes(423..427),
210    },
211    Ident {
212        ident: "E",
213        span: #11 bytes(428..429),
214    },
215    Group {
216        delimiter: Brace,
217        stream: TokenStream [
218            Ident {
219                ident: "V",
220                span: #11 bytes(444..445),
221            },
222            Punct {
223                ch: '=',
224                spacing: Alone,
225                span: #11 bytes(446..447),
226            },
227            Group {
228                delimiter: Brace,
229                stream: TokenStream [
230                    Ident {
231                        ident: "let",
232                        span: #11 bytes(450..453),
233                    },
234                    Ident {
235                        ident: "_",
236                        span: #11 bytes(454..455),
237                    },
238                    Punct {
239                        ch: '=',
240                        spacing: Alone,
241                        span: #11 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: #11 bytes(460..465),
256                            },
257                        ],
258                        span: #11 bytes(458..467),
259                    },
260                    Punct {
261                        ch: ';',
262                        spacing: Alone,
263                        span: #11 bytes(467..468),
264                    },
265                    Literal {
266                        kind: Integer,
267                        symbol: "0",
268                        suffix: None,
269                        span: #11 bytes(469..470),
270                    },
271                ],
272                span: #11 bytes(448..472),
273            },
274            Punct {
275                ch: ',',
276                spacing: Alone,
277                span: #11 bytes(472..473),
278            },
279        ],
280        span: #11 bytes(430..483),
281    },
282]
283PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { PATH; } ; 0 }, }
284PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { PATH } ; 0 }, }
285PRINT-DERIVE INPUT (DEBUG): TokenStream [
286    Ident {
287        ident: "enum",
288        span: #15 bytes(423..427),
289    },
290    Ident {
291        ident: "E",
292        span: #15 bytes(428..429),
293    },
294    Group {
295        delimiter: Brace,
296        stream: TokenStream [
297            Ident {
298                ident: "V",
299                span: #15 bytes(444..445),
300            },
301            Punct {
302                ch: '=',
303                spacing: Alone,
304                span: #15 bytes(446..447),
305            },
306            Group {
307                delimiter: Brace,
308                stream: TokenStream [
309                    Ident {
310                        ident: "let",
311                        span: #15 bytes(450..453),
312                    },
313                    Ident {
314                        ident: "_",
315                        span: #15 bytes(454..455),
316                    },
317                    Punct {
318                        ch: '=',
319                        spacing: Alone,
320                        span: #15 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: #15 bytes(460..465),
334                            },
335                        ],
336                        span: #15 bytes(458..467),
337                    },
338                    Punct {
339                        ch: ';',
340                        spacing: Alone,
341                        span: #15 bytes(467..468),
342                    },
343                    Literal {
344                        kind: Integer,
345                        symbol: "0",
346                        suffix: None,
347                        span: #15 bytes(469..470),
348                    },
349                ],
350                span: #15 bytes(448..472),
351            },
352            Punct {
353                ch: ',',
354                spacing: Alone,
355                span: #15 bytes(472..473),
356            },
357        ],
358        span: #15 bytes(430..483),
359    },
360]
361PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { 0 + 1; } ; 0 }, }
362PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { 0 + 1 } ; 0 }, }
363PRINT-DERIVE INPUT (DEBUG): TokenStream [
364    Ident {
365        ident: "enum",
366        span: #19 bytes(423..427),
367    },
368    Ident {
369        ident: "E",
370        span: #19 bytes(428..429),
371    },
372    Group {
373        delimiter: Brace,
374        stream: TokenStream [
375            Ident {
376                ident: "V",
377                span: #19 bytes(444..445),
378            },
379            Punct {
380                ch: '=',
381                spacing: Alone,
382                span: #19 bytes(446..447),
383            },
384            Group {
385                delimiter: Brace,
386                stream: TokenStream [
387                    Ident {
388                        ident: "let",
389                        span: #19 bytes(450..453),
390                    },
391                    Ident {
392                        ident: "_",
393                        span: #19 bytes(454..455),
394                    },
395                    Punct {
396                        ch: '=',
397                        spacing: Alone,
398                        span: #19 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: #19 bytes(460..465),
425                            },
426                        ],
427                        span: #19 bytes(458..467),
428                    },
429                    Punct {
430                        ch: ';',
431                        spacing: Alone,
432                        span: #19 bytes(467..468),
433                    },
434                    Literal {
435                        kind: Integer,
436                        symbol: "0",
437                        suffix: None,
438                        span: #19 bytes(469..470),
439                    },
440                ],
441                span: #19 bytes(448..472),
442            },
443            Punct {
444                ch: ',',
445                spacing: Alone,
446                span: #19 bytes(472..473),
447            },
448        ],
449        span: #19 bytes(430..483),
450    },
451]
452PRINT-DERIVE INPUT (DISPLAY): enum E { V = { let _ = { PATH + 1; } ; 0 }, }
453PRINT-DERIVE DEEP-RE-COLLECTED (DISPLAY): enum E { V = { let _ = { PATH + 1 } ; 0 }, }
454PRINT-DERIVE INPUT (DEBUG): TokenStream [
455    Ident {
456        ident: "enum",
457        span: #23 bytes(423..427),
458    },
459    Ident {
460        ident: "E",
461        span: #23 bytes(428..429),
462    },
463    Group {
464        delimiter: Brace,
465        stream: TokenStream [
466            Ident {
467                ident: "V",
468                span: #23 bytes(444..445),
469            },
470            Punct {
471                ch: '=',
472                spacing: Alone,
473                span: #23 bytes(446..447),
474            },
475            Group {
476                delimiter: Brace,
477                stream: TokenStream [
478                    Ident {
479                        ident: "let",
480                        span: #23 bytes(450..453),
481                    },
482                    Ident {
483                        ident: "_",
484                        span: #23 bytes(454..455),
485                    },
486                    Punct {
487                        ch: '=',
488                        spacing: Alone,
489                        span: #23 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: #23 bytes(460..465),
514                            },
515                        ],
516                        span: #23 bytes(458..467),
517                    },
518                    Punct {
519                        ch: ';',
520                        spacing: Alone,
521                        span: #23 bytes(467..468),
522                    },
523                    Literal {
524                        kind: Integer,
525                        symbol: "0",
526                        suffix: None,
527                        span: #23 bytes(469..470),
528                    },
529                ],
530                span: #23 bytes(448..472),
531            },
532            Punct {
533                ch: ',',
534                spacing: Alone,
535                span: #23 bytes(472..473),
536            },
537        ],
538        span: #23 bytes(430..483),
539    },
540]