aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_hir_ty/src/tests/simple.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_hir_ty/src/tests/simple.rs')
-rw-r--r--crates/ra_hir_ty/src/tests/simple.rs1654
1 files changed, 827 insertions, 827 deletions
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index 37659cd02..d7ef9add6 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -64,9 +64,9 @@ impl S<u32> {
64} 64}
65"#, 65"#,
66 ), @r###" 66 ), @r###"
67 63..93 '{ ... }': () 67 49..79 '{ ... }': ()
68 73..86 'Self { x: 1 }': S<u32> 68 59..72 'Self { x: 1 }': S<u32>
69 83..84 '1': u32 69 69..70 '1': u32
70 "###); 70 "###);
71} 71}
72 72
@@ -85,9 +85,9 @@ fn foo() {
85 85
86"#, 86"#,
87 ), @r###" 87 ), @r###"
88 64..84 '{ ...1 }; }': () 88 50..70 '{ ...1 }; }': ()
89 70..81 'SS { x: 1 }': S<u32> 89 56..67 'SS { x: 1 }': S<u32>
90 78..79 '1': u32 90 64..65 '1': u32
91 "###); 91 "###);
92} 92}
93 93
@@ -175,19 +175,19 @@ fn test(a: u32, b: isize, c: !, d: &str) {
175 1.0f32; 175 1.0f32;
176}"#), 176}"#),
177 @r###" 177 @r###"
178 9..10 'a': u32 178 8..9 'a': u32
179 17..18 'b': isize 179 16..17 'b': isize
180 27..28 'c': ! 180 26..27 'c': !
181 33..34 'd': &str 181 32..33 'd': &str
182 42..121 '{ ...f32; }': () 182 41..120 '{ ...f32; }': ()
183 48..49 'a': u32 183 47..48 'a': u32
184 55..56 'b': isize 184 54..55 'b': isize
185 62..63 'c': ! 185 61..62 'c': !
186 69..70 'd': &str 186 68..69 'd': &str
187 76..82 '1usize': usize 187 75..81 '1usize': usize
188 88..94 '1isize': isize 188 87..93 '1isize': isize
189 100..106 '"test"': &str 189 99..105 '"test"': &str
190 112..118 '1.0f32': f32 190 111..117 '1.0f32': f32
191 "### 191 "###
192 ); 192 );
193} 193}
@@ -206,17 +206,17 @@ fn test() {
206} 206}
207"#), 207"#),
208 @r###" 208 @r###"
209 11..118 '{ ...= e; }': () 209 10..117 '{ ...= e; }': ()
210 21..22 'a': isize 210 20..21 'a': isize
211 25..31 '1isize': isize 211 24..30 '1isize': isize
212 41..42 'b': usize 212 40..41 'b': usize
213 52..53 '1': usize 213 51..52 '1': usize
214 63..64 'c': usize 214 62..63 'c': usize
215 67..68 'b': usize 215 66..67 'b': usize
216 78..79 'd': u32 216 77..78 'd': u32
217 94..95 'e': i32 217 93..94 'e': i32
218 105..106 'f': i32 218 104..105 'f': i32
219 114..115 'e': i32 219 113..114 'e': i32
220 "### 220 "###
221 ); 221 );
222} 222}
@@ -237,15 +237,15 @@ fn test() {
237} 237}
238"#), 238"#),
239 @r###" 239 @r###"
240 15..20 '{ 1 }': u32 240 14..19 '{ 1 }': u32
241 17..18 '1': u32 241 16..17 '1': u32
242 48..53 '{ 1 }': u32 242 47..52 '{ 1 }': u32
243 50..51 '1': u32 243 49..50 '1': u32
244 67..91 '{ ...c(); }': () 244 66..90 '{ ...c(); }': ()
245 73..74 'a': fn a() -> u32 245 72..73 'a': fn a() -> u32
246 73..76 'a()': u32 246 72..75 'a()': u32
247 82..86 'b::c': fn c() -> u32 247 81..85 'b::c': fn c() -> u32
248 82..88 'b::c()': u32 248 81..87 'b::c()': u32
249 "### 249 "###
250 ); 250 );
251} 251}
@@ -266,13 +266,13 @@ fn test() {
266} 266}
267"#), 267"#),
268 @r###" 268 @r###"
269 41..46 '{ 1 }': i32 269 40..45 '{ 1 }': i32
270 43..44 '1': i32 270 42..43 '1': i32
271 60..93 '{ ...o(); }': () 271 59..92 '{ ...o(); }': ()
272 66..72 'S::foo': fn foo() -> i32 272 65..71 'S::foo': fn foo() -> i32
273 66..74 'S::foo()': i32 273 65..73 'S::foo()': i32
274 80..88 '<S>::foo': fn foo() -> i32 274 79..87 '<S>::foo': fn foo() -> i32
275 80..90 '<S>::foo()': i32 275 79..89 '<S>::foo()': i32
276 "### 276 "###
277 ); 277 );
278} 278}
@@ -297,22 +297,22 @@ fn test() {
297} 297}
298"#), 298"#),
299 @r###" 299 @r###"
300 72..154 '{ ...a.c; }': () 300 71..153 '{ ...a.c; }': ()
301 82..83 'c': C 301 81..82 'c': C
302 86..87 'C': C(usize) -> C 302 85..86 'C': C(usize) -> C
303 86..90 'C(1)': C 303 85..89 'C(1)': C
304 88..89 '1': usize 304 87..88 '1': usize
305 96..97 'B': B 305 95..96 'B': B
306 107..108 'a': A 306 106..107 'a': A
307 114..133 'A { b:...C(1) }': A 307 113..132 'A { b:...C(1) }': A
308 121..122 'B': B 308 120..121 'B': B
309 127..128 'C': C(usize) -> C 309 126..127 'C': C(usize) -> C
310 127..131 'C(1)': C 310 126..130 'C(1)': C
311 129..130 '1': usize 311 128..129 '1': usize
312 139..140 'a': A 312 138..139 'a': A
313 139..142 'a.b': B 313 138..141 'a.b': B
314 148..149 'a': A 314 147..148 'a': A
315 148..151 'a.c': C 315 147..150 'a.c': C
316 "### 316 "###
317 ); 317 );
318} 318}
@@ -330,10 +330,10 @@ fn test() {
330 E::V2; 330 E::V2;
331}"#), 331}"#),
332 @r###" 332 @r###"
333 48..82 '{ E:...:V2; }': () 333 47..81 '{ E:...:V2; }': ()
334 52..70 'E::V1 ...d: 1 }': E 334 51..69 'E::V1 ...d: 1 }': E
335 67..68 '1': u32 335 66..67 '1': u32
336 74..79 'E::V2': E 336 73..78 'E::V2': E
337 "### 337 "###
338 ); 338 );
339} 339}
@@ -357,29 +357,29 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
357} 357}
358"#), 358"#),
359 @r###" 359 @r###"
360 9..10 'a': &u32 360 8..9 'a': &u32
361 18..19 'b': &mut u32 361 17..18 'b': &mut u32
362 31..32 'c': *const u32 362 30..31 'c': *const u32
363 46..47 'd': *mut u32 363 45..46 'd': *mut u32
364 59..150 '{ ... *d; }': () 364 58..149 '{ ... *d; }': ()
365 65..66 'a': &u32 365 64..65 'a': &u32
366 72..74 '*a': u32 366 71..73 '*a': u32
367 73..74 'a': &u32 367 72..73 'a': &u32
368 80..82 '&a': &&u32 368 79..81 '&a': &&u32
369 81..82 'a': &u32 369 80..81 'a': &u32
370 88..94 '&mut a': &mut &u32 370 87..93 '&mut a': &mut &u32
371 93..94 'a': &u32 371 92..93 'a': &u32
372 100..101 'b': &mut u32 372 99..100 'b': &mut u32
373 107..109 '*b': u32 373 106..108 '*b': u32
374 108..109 'b': &mut u32 374 107..108 'b': &mut u32
375 115..117 '&b': &&mut u32 375 114..116 '&b': &&mut u32
376 116..117 'b': &mut u32 376 115..116 'b': &mut u32
377 123..124 'c': *const u32 377 122..123 'c': *const u32
378 130..132 '*c': u32 378 129..131 '*c': u32
379 131..132 'c': *const u32 379 130..131 'c': *const u32
380 138..139 'd': *mut u32 380 137..138 'd': *mut u32
381 145..147 '*d': u32 381 144..146 '*d': u32
382 146..147 'd': *mut u32 382 145..146 'd': *mut u32
383 "### 383 "###
384 ); 384 );
385} 385}
@@ -394,12 +394,12 @@ fn test(a: i32) {
394} 394}
395"#), 395"#),
396 @r###" 396 @r###"
397 9..10 'a': i32 397 8..9 'a': i32
398 17..54 '{ ...t a; }': () 398 16..53 '{ ...t a; }': ()
399 23..33 '&raw mut a': *mut i32 399 22..32 '&raw mut a': *mut i32
400 32..33 'a': i32 400 31..32 'a': i32
401 39..51 '&raw const a': *const i32 401 38..50 '&raw const a': *const i32
402 50..51 'a': i32 402 49..50 'a': i32
403 "### 403 "###
404 ); 404 );
405} 405}
@@ -429,20 +429,20 @@ fn test() {
429} 429}
430"##), 430"##),
431 @r###" 431 @r###"
432 11..221 '{ ...o"#; }': () 432 10..220 '{ ...o"#; }': ()
433 17..21 '5i32': i32 433 16..20 '5i32': i32
434 27..31 '5f32': f32 434 26..30 '5f32': f32
435 37..41 '5f64': f64 435 36..40 '5f64': f64
436 47..54 '"hello"': &str 436 46..53 '"hello"': &str
437 60..68 'b"bytes"': &[u8; _] 437 59..67 'b"bytes"': &[u8; _]
438 74..77 ''c'': char 438 73..76 ''c'': char
439 83..87 'b'b'': u8 439 82..86 'b'b'': u8
440 93..97 '3.14': f64 440 92..96 '3.14': f64
441 103..107 '5000': i32 441 102..106 '5000': i32
442 113..118 'false': bool 442 112..117 'false': bool
443 124..128 'true': bool 443 123..127 'true': bool
444 134..202 'r#" ... "#': &str 444 133..201 'r#" ... "#': &str
445 208..218 'br#"yolo"#': &[u8; _] 445 207..217 'br#"yolo"#': &[u8; _]
446 "### 446 "###
447 ); 447 );
448} 448}
@@ -472,47 +472,47 @@ fn test(x: SomeType) {
472} 472}
473"#), 473"#),
474 @r###" 474 @r###"
475 27..28 'x': SomeType 475 26..27 'x': SomeType
476 40..272 '{ ...lo"; }': () 476 39..271 '{ ...lo"; }': ()
477 50..51 'b': bool 477 49..50 'b': bool
478 54..59 'false': bool 478 53..58 'false': bool
479 69..70 'c': bool 479 68..69 'c': bool
480 73..75 '!b': bool 480 72..74 '!b': bool
481 74..75 'b': bool 481 73..74 'b': bool
482 85..86 'a': i128 482 84..85 'a': i128
483 89..92 '100': i128 483 88..91 '100': i128
484 102..103 'd': i128 484 101..102 'd': i128
485 112..114 '-a': i128 485 111..113 '-a': i128
486 113..114 'a': i128 486 112..113 'a': i128
487 124..125 'e': i32 487 123..124 'e': i32
488 128..132 '-100': i32 488 127..131 '-100': i32
489 129..132 '100': i32 489 128..131 '100': i32
490 142..143 'f': bool 490 141..142 'f': bool
491 146..153 '!!!true': bool 491 145..152 '!!!true': bool
492 147..153 '!!true': bool 492 146..152 '!!true': bool
493 148..153 '!true': bool 493 147..152 '!true': bool
494 149..153 'true': bool 494 148..152 'true': bool
495 163..164 'g': i32 495 162..163 'g': i32
496 167..170 '!42': i32 496 166..169 '!42': i32
497 168..170 '42': i32 497 167..169 '42': i32
498 180..181 'h': u32 498 179..180 'h': u32
499 184..190 '!10u32': u32 499 183..189 '!10u32': u32
500 185..190 '10u32': u32 500 184..189 '10u32': u32
501 200..201 'j': i128 501 199..200 'j': i128
502 204..206 '!a': i128 502 203..205 '!a': i128
503 205..206 'a': i128 503 204..205 'a': i128
504 212..217 '-3.14': f64 504 211..216 '-3.14': f64
505 213..217 '3.14': f64 505 212..216 '3.14': f64
506 223..225 '!3': i32 506 222..224 '!3': i32
507 224..225 '3': i32 507 223..224 '3': i32
508 231..233 '-x': {unknown} 508 230..232 '-x': {unknown}
509 232..233 'x': SomeType 509 231..232 'x': SomeType
510 239..241 '!x': {unknown} 510 238..240 '!x': {unknown}
511 240..241 'x': SomeType 511 239..240 'x': SomeType
512 247..255 '-"hello"': {unknown} 512 246..254 '-"hello"': {unknown}
513 248..255 '"hello"': &str 513 247..254 '"hello"': &str
514 261..269 '!"hello"': {unknown} 514 260..268 '!"hello"': {unknown}
515 262..269 '"hello"': &str 515 261..268 '"hello"': &str
516 "### 516 "###
517 ); 517 );
518} 518}
@@ -535,26 +535,26 @@ fn test() -> &mut &f64 {
535} 535}
536"#), 536"#),
537 @r###" 537 @r###"
538 14..15 'x': u32 538 13..14 'x': u32
539 22..24 '{}': () 539 21..23 '{}': ()
540 78..231 '{ ...t &c }': &mut &f64 540 77..230 '{ ...t &c }': &mut &f64
541 88..89 'a': u32 541 87..88 'a': u32
542 92..108 'unknow...nction': {unknown} 542 91..107 'unknow...nction': {unknown}
543 92..110 'unknow...tion()': u32 543 91..109 'unknow...tion()': u32
544 116..125 'takes_u32': fn takes_u32(u32) 544 115..124 'takes_u32': fn takes_u32(u32)
545 116..128 'takes_u32(a)': () 545 115..127 'takes_u32(a)': ()
546 126..127 'a': u32 546 125..126 'a': u32
547 138..139 'b': i32 547 137..138 'b': i32
548 142..158 'unknow...nction': {unknown} 548 141..157 'unknow...nction': {unknown}
549 142..160 'unknow...tion()': i32 549 141..159 'unknow...tion()': i32
550 166..184 'S { i3...d: b }': S 550 165..183 'S { i3...d: b }': S
551 181..182 'b': i32 551 180..181 'b': i32
552 194..195 'c': f64 552 193..194 'c': f64
553 198..214 'unknow...nction': {unknown} 553 197..213 'unknow...nction': {unknown}
554 198..216 'unknow...tion()': f64 554 197..215 'unknow...tion()': f64
555 222..229 '&mut &c': &mut &f64 555 221..228 '&mut &c': &mut &f64
556 227..229 '&c': &f64 556 226..228 '&c': &f64
557 228..229 'c': f64 557 227..228 'c': f64
558 "### 558 "###
559 ); 559 );
560} 560}
@@ -581,16 +581,16 @@ impl S {
581} 581}
582"#), 582"#),
583 @r###" 583 @r###"
584 34..38 'self': &S 584 33..37 'self': &S
585 40..61 '{ ... }': () 585 39..60 '{ ... }': ()
586 50..54 'self': &S 586 49..53 'self': &S
587 75..79 'self': &S 587 74..78 'self': &S
588 88..109 '{ ... }': () 588 87..108 '{ ... }': ()
589 98..102 'self': &S 589 97..101 'self': &S
590 133..153 '{ ... }': S 590 132..152 '{ ... }': S
591 143..147 'S {}': S 591 142..146 'S {}': S
592 177..200 '{ ... }': S 592 176..199 '{ ... }': S
593 187..194 'Self {}': S 593 186..193 'Self {}': S
594 "### 594 "###
595 ); 595 );
596} 596}
@@ -624,17 +624,17 @@ impl E {
624} 624}
625"#), 625"#),
626 @r###" 626 @r###"
627 87..108 '{ ... }': () 627 86..107 '{ ... }': ()
628 97..101 'Self': S1 628 96..100 'Self': S1
629 135..159 '{ ... }': () 629 134..158 '{ ... }': ()
630 145..149 'Self': S2(isize) -> S2 630 144..148 'Self': S2(isize) -> S2
631 145..152 'Self(1)': S2 631 144..151 'Self(1)': S2
632 150..151 '1': isize 632 149..150 '1': isize
633 185..231 '{ ... }': () 633 184..230 '{ ... }': ()
634 195..203 'Self::V1': E 634 194..202 'Self::V1': E
635 213..221 'Self::V2': V2(u32) -> E 635 212..220 'Self::V2': V2(u32) -> E
636 213..224 'Self::V2(1)': E 636 212..223 'Self::V2(1)': E
637 222..223 '1': u32 637 221..222 '1': u32
638 "### 638 "###
639 ); 639 );
640} 640}
@@ -664,56 +664,56 @@ fn test() -> bool {
664} 664}
665"#), 665"#),
666 @r###" 666 @r###"
667 6..7 'x': bool 667 5..6 'x': bool
668 22..34 '{ 0i32 }': i32 668 21..33 '{ 0i32 }': i32
669 28..32 '0i32': i32 669 27..31 '0i32': i32
670 54..370 '{ ... < 3 }': bool 670 53..369 '{ ... < 3 }': bool
671 64..65 'x': bool 671 63..64 'x': bool
672 68..69 'a': bool 672 67..68 'a': bool
673 68..74 'a && b': bool 673 67..73 'a && b': bool
674 73..74 'b': bool 674 72..73 'b': bool
675 84..85 'y': bool 675 83..84 'y': bool
676 88..92 'true': bool 676 87..91 'true': bool
677 88..101 'true || false': bool 677 87..100 'true || false': bool
678 96..101 'false': bool 678 95..100 'false': bool
679 111..112 'z': bool 679 110..111 'z': bool
680 115..116 'x': bool 680 114..115 'x': bool
681 115..121 'x == y': bool 681 114..120 'x == y': bool
682 120..121 'y': bool 682 119..120 'y': bool
683 131..132 't': bool 683 130..131 't': bool
684 135..136 'x': bool 684 134..135 'x': bool
685 135..141 'x != y': bool 685 134..140 'x != y': bool
686 140..141 'y': bool 686 139..140 'y': bool
687 151..162 'minus_forty': isize 687 150..161 'minus_forty': isize
688 172..180 '-40isize': isize 688 171..179 '-40isize': isize
689 173..180 '40isize': isize 689 172..179 '40isize': isize
690 190..191 'h': bool 690 189..190 'h': bool
691 194..205 'minus_forty': isize 691 193..204 'minus_forty': isize
692 194..216 'minus_...ONST_2': bool 692 193..215 'minus_...ONST_2': bool
693 209..216 'CONST_2': isize 693 208..215 'CONST_2': isize
694 226..227 'c': i32 694 225..226 'c': i32
695 230..231 'f': fn f(bool) -> i32 695 229..230 'f': fn f(bool) -> i32
696 230..239 'f(z || y)': i32 696 229..238 'f(z || y)': i32
697 230..243 'f(z || y) + 5': i32 697 229..242 'f(z || y) + 5': i32
698 232..233 'z': bool 698 231..232 'z': bool
699 232..238 'z || y': bool 699 231..237 'z || y': bool
700 237..238 'y': bool 700 236..237 'y': bool
701 242..243 '5': i32 701 241..242 '5': i32
702 253..254 'd': {unknown} 702 252..253 'd': {unknown}
703 257..258 'b': {unknown} 703 256..257 'b': {unknown}
704 268..269 'g': () 704 267..268 'g': ()
705 272..283 'minus_forty': isize 705 271..282 'minus_forty': isize
706 272..288 'minus_...y ^= i': () 706 271..287 'minus_...y ^= i': ()
707 287..288 'i': isize 707 286..287 'i': isize
708 298..301 'ten': usize 708 297..300 'ten': usize
709 311..313 '10': usize 709 310..312 '10': usize
710 323..336 'ten_is_eleven': bool 710 322..335 'ten_is_eleven': bool
711 339..342 'ten': usize 711 338..341 'ten': usize
712 339..354 'ten == some_num': bool 712 338..353 'ten == some_num': bool
713 346..354 'some_num': usize 713 345..353 'some_num': usize
714 361..364 'ten': usize 714 360..363 'ten': usize
715 361..368 'ten < 3': bool 715 360..367 'ten < 3': bool
716 367..368 '3': usize 716 366..367 '3': usize
717 "### 717 "###
718 ); 718 );
719} 719}
@@ -728,13 +728,13 @@ fn test() {
728} 728}
729"#), 729"#),
730 @r###" 730 @r###"
731 11..48 '{ ...5u8; }': () 731 10..47 '{ ...5u8; }': ()
732 17..21 '1u32': u32 732 16..20 '1u32': u32
733 17..28 '1u32 << 5u8': u32 733 16..27 '1u32 << 5u8': u32
734 25..28 '5u8': u8 734 24..27 '5u8': u8
735 34..38 '1u32': u32 735 33..37 '1u32': u32
736 34..45 '1u32 >> 5u8': u32 736 33..44 '1u32 >> 5u8': u32
737 42..45 '5u8': u8 737 41..44 '5u8': u8
738 "### 738 "###
739 ); 739 );
740} 740}
@@ -767,49 +767,49 @@ fn test2(a1: *const A, a2: *mut A) {
767} 767}
768"#), 768"#),
769 @r###" 769 @r###"
770 44..45 'a': A 770 43..44 'a': A
771 50..213 '{ ...5.b; }': () 771 49..212 '{ ...5.b; }': ()
772 60..62 'a1': A 772 59..61 'a1': A
773 65..66 'a': A 773 64..65 'a': A
774 72..74 'a1': A 774 71..73 'a1': A
775 72..76 'a1.b': B 775 71..75 'a1.b': B
776 86..88 'a2': &A 776 85..87 'a2': &A
777 91..93 '&a': &A 777 90..92 '&a': &A
778 92..93 'a': A 778 91..92 'a': A
779 99..101 'a2': &A 779 98..100 'a2': &A
780 99..103 'a2.b': B 780 98..102 'a2.b': B
781 113..115 'a3': &mut A 781 112..114 'a3': &mut A
782 118..124 '&mut a': &mut A 782 117..123 '&mut a': &mut A
783 123..124 'a': A 783 122..123 'a': A
784 130..132 'a3': &mut A 784 129..131 'a3': &mut A
785 130..134 'a3.b': B 785 129..133 'a3.b': B
786 144..146 'a4': &&&&&&&A 786 143..145 'a4': &&&&&&&A
787 149..157 '&&&&&&&a': &&&&&&&A 787 148..156 '&&&&&&&a': &&&&&&&A
788 150..157 '&&&&&&a': &&&&&&A 788 149..156 '&&&&&&a': &&&&&&A
789 151..157 '&&&&&a': &&&&&A 789 150..156 '&&&&&a': &&&&&A
790 152..157 '&&&&a': &&&&A 790 151..156 '&&&&a': &&&&A
791 153..157 '&&&a': &&&A 791 152..156 '&&&a': &&&A
792 154..157 '&&a': &&A 792 153..156 '&&a': &&A
793 155..157 '&a': &A 793 154..156 '&a': &A
794 156..157 'a': A 794 155..156 'a': A
795 163..165 'a4': &&&&&&&A 795 162..164 'a4': &&&&&&&A
796 163..167 'a4.b': B 796 162..166 'a4.b': B
797 177..179 'a5': &mut &&mut &&mut A 797 176..178 'a5': &mut &&mut &&mut A
798 182..200 '&mut &...&mut a': &mut &&mut &&mut A 798 181..199 '&mut &...&mut a': &mut &&mut &&mut A
799 187..200 '&&mut &&mut a': &&mut &&mut A 799 186..199 '&&mut &&mut a': &&mut &&mut A
800 188..200 '&mut &&mut a': &mut &&mut A 800 187..199 '&mut &&mut a': &mut &&mut A
801 193..200 '&&mut a': &&mut A 801 192..199 '&&mut a': &&mut A
802 194..200 '&mut a': &mut A 802 193..199 '&mut a': &mut A
803 199..200 'a': A 803 198..199 'a': A
804 206..208 'a5': &mut &&mut &&mut A 804 205..207 'a5': &mut &&mut &&mut A
805 206..210 'a5.b': B 805 205..209 'a5.b': B
806 224..226 'a1': *const A 806 223..225 'a1': *const A
807 238..240 'a2': *mut A 807 237..239 'a2': *mut A
808 250..273 '{ ...2.b; }': () 808 249..272 '{ ...2.b; }': ()
809 256..258 'a1': *const A 809 255..257 'a1': *const A
810 256..260 'a1.b': B 810 255..259 'a1.b': B
811 266..268 'a2': *mut A 811 265..267 'a2': *mut A
812 266..270 'a2.b': B 812 265..269 'a2.b': B
813 "### 813 "###
814 ); 814 );
815} 815}
@@ -846,30 +846,30 @@ fn test() {
846} 846}
847"#), 847"#),
848 @r###" 848 @r###"
849 68..72 'self': &Self 849 67..71 'self': &Self
850 139..143 'self': &A<T> 850 138..142 'self': &A<T>
851 151..174 '{ ... }': &T 851 150..173 '{ ... }': &T
852 161..168 '&self.0': &T 852 160..167 '&self.0': &T
853 162..166 'self': &A<T> 853 161..165 'self': &A<T>
854 162..168 'self.0': T 854 161..167 'self.0': T
855 255..259 'self': &B<T> 855 254..258 'self': &B<T>
856 278..301 '{ ... }': &T 856 277..300 '{ ... }': &T
857 288..295 '&self.0': &T 857 287..294 '&self.0': &T
858 289..293 'self': &B<T> 858 288..292 'self': &B<T>
859 289..295 'self.0': T 859 288..294 'self.0': T
860 315..353 '{ ...))); }': () 860 314..352 '{ ...))); }': ()
861 325..326 't': &i32 861 324..325 't': &i32
862 329..335 'A::foo': fn foo<i32>(&A<i32>) -> &i32 862 328..334 'A::foo': fn foo<i32>(&A<i32>) -> &i32
863 329..350 'A::foo...42))))': &i32 863 328..349 'A::foo...42))))': &i32
864 336..349 '&&B(B(A(42)))': &&B<B<A<i32>>> 864 335..348 '&&B(B(A(42)))': &&B<B<A<i32>>>
865 337..349 '&B(B(A(42)))': &B<B<A<i32>>> 865 336..348 '&B(B(A(42)))': &B<B<A<i32>>>
866 338..339 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> 866 337..338 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
867 338..349 'B(B(A(42)))': B<B<A<i32>>> 867 337..348 'B(B(A(42)))': B<B<A<i32>>>
868 340..341 'B': B<A<i32>>(A<i32>) -> B<A<i32>> 868 339..340 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
869 340..348 'B(A(42))': B<A<i32>> 869 339..347 'B(A(42))': B<A<i32>>
870 342..343 'A': A<i32>(i32) -> A<i32> 870 341..342 'A': A<i32>(i32) -> A<i32>
871 342..347 'A(42)': A<i32> 871 341..346 'A(42)': A<i32>
872 344..346 '42': i32 872 343..345 '42': i32
873 "### 873 "###
874 ); 874 );
875} 875}
@@ -906,34 +906,34 @@ fn test(a: A<i32>) {
906} 906}
907"#), 907"#),
908 @r###" 908 @r###"
909 68..72 'self': &Self 909 67..71 'self': &Self
910 144..148 'self': &A<T> 910 143..147 'self': &A<T>
911 150..151 'x': &A<T> 911 149..150 'x': &A<T>
912 166..187 '{ ... }': &T 912 165..186 '{ ... }': &T
913 176..181 '&*x.0': &T 913 175..180 '&*x.0': &T
914 177..181 '*x.0': T 914 176..180 '*x.0': T
915 178..179 'x': &A<T> 915 177..178 'x': &A<T>
916 178..181 'x.0': *mut T 916 177..180 'x.0': *mut T
917 268..272 'self': &B<T> 917 267..271 'self': &B<T>
918 291..314 '{ ... }': &T 918 290..313 '{ ... }': &T
919 301..308 '&self.0': &T 919 300..307 '&self.0': &T
920 302..306 'self': &B<T> 920 301..305 'self': &B<T>
921 302..308 'self.0': T 921 301..307 'self.0': T
922 326..327 'a': A<i32> 922 325..326 'a': A<i32>
923 337..383 '{ ...))); }': () 923 336..382 '{ ...))); }': ()
924 347..348 't': &i32 924 346..347 't': &i32
925 351..352 'A': A<i32>(*mut i32) -> A<i32> 925 350..351 'A': A<i32>(*mut i32) -> A<i32>
926 351..365 'A(0 as *mut _)': A<i32> 926 350..364 'A(0 as *mut _)': A<i32>
927 351..380 'A(0 as...B(a)))': &i32 927 350..379 'A(0 as...B(a)))': &i32
928 353..354 '0': i32 928 352..353 '0': i32
929 353..364 '0 as *mut _': *mut i32 929 352..363 '0 as *mut _': *mut i32
930 370..379 '&&B(B(a))': &&B<B<A<i32>>> 930 369..378 '&&B(B(a))': &&B<B<A<i32>>>
931 371..379 '&B(B(a))': &B<B<A<i32>>> 931 370..378 '&B(B(a))': &B<B<A<i32>>>
932 372..373 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>> 932 371..372 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
933 372..379 'B(B(a))': B<B<A<i32>>> 933 371..378 'B(B(a))': B<B<A<i32>>>
934 374..375 'B': B<A<i32>>(A<i32>) -> B<A<i32>> 934 373..374 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
935 374..378 'B(a)': B<A<i32>> 935 373..377 'B(a)': B<A<i32>>
936 376..377 'a': A<i32> 936 375..376 'a': A<i32>
937 "### 937 "###
938 ); 938 );
939} 939}
@@ -952,16 +952,16 @@ fn main(foo: Foo) {
952} 952}
953"#), 953"#),
954 @r###" 954 @r###"
955 35..38 'foo': Foo 955 34..37 'foo': Foo
956 45..109 '{ ... } }': () 956 44..108 '{ ... } }': ()
957 51..107 'if tru... }': () 957 50..106 'if tru... }': ()
958 54..58 'true': bool 958 53..57 'true': bool
959 59..67 '{ }': () 959 58..66 '{ }': ()
960 73..107 'if fal... }': i32 960 72..106 'if fal... }': i32
961 76..81 'false': bool 961 75..80 'false': bool
962 82..107 '{ ... }': i32 962 81..106 '{ ... }': i32
963 92..95 'foo': Foo 963 91..94 'foo': Foo
964 92..101 'foo.field': i32 964 91..100 'foo.field': i32
965 "### 965 "###
966 ) 966 )
967} 967}
@@ -993,38 +993,38 @@ fn foo() {
993 }; 993 };
994}"#), 994}"#),
995 @r###" 995 @r###"
996 10..323 '{ ... }; }': () 996 9..322 '{ ... }; }': ()
997 20..23 '_x1': i32 997 19..22 '_x1': i32
998 26..80 'if tru... }': i32 998 25..79 'if tru... }': i32
999 29..33 'true': bool 999 28..32 'true': bool
1000 34..51 '{ ... }': i32 1000 33..50 '{ ... }': i32
1001 44..45 '1': i32 1001 43..44 '1': i32
1002 57..80 '{ ... }': i32 1002 56..79 '{ ... }': i32
1003 67..73 'return': ! 1003 66..72 'return': !
1004 90..93 '_x2': i32 1004 89..92 '_x2': i32
1005 96..149 'if tru... }': i32 1005 95..148 'if tru... }': i32
1006 99..103 'true': bool 1006 98..102 'true': bool
1007 104..121 '{ ... }': i32 1007 103..120 '{ ... }': i32
1008 114..115 '2': i32 1008 113..114 '2': i32
1009 127..149 '{ ... }': ! 1009 126..148 '{ ... }': !
1010 137..143 'return': ! 1010 136..142 'return': !
1011 159..162 '_x3': i32 1011 158..161 '_x3': i32
1012 165..247 'match ... }': i32 1012 164..246 'match ... }': i32
1013 171..175 'true': bool 1013 170..174 'true': bool
1014 186..190 'true': bool 1014 185..189 'true': bool
1015 186..190 'true': bool 1015 185..189 'true': bool
1016 194..195 '3': i32 1016 193..194 '3': i32
1017 205..206 '_': bool 1017 204..205 '_': bool
1018 210..241 '{ ... }': i32 1018 209..240 '{ ... }': i32
1019 224..230 'return': ! 1019 223..229 'return': !
1020 257..260 '_x4': i32 1020 256..259 '_x4': i32
1021 263..320 'match ... }': i32 1021 262..319 'match ... }': i32
1022 269..273 'true': bool 1022 268..272 'true': bool
1023 284..288 'true': bool 1023 283..287 'true': bool
1024 284..288 'true': bool 1024 283..287 'true': bool
1025 292..293 '4': i32 1025 291..292 '4': i32
1026 303..304 '_': bool 1026 302..303 '_': bool
1027 308..314 'return': ! 1027 307..313 'return': !
1028 "### 1028 "###
1029 ) 1029 )
1030} 1030}
@@ -1052,24 +1052,24 @@ fn test(a: A) {
1052} 1052}
1053"#), 1053"#),
1054 @r###" 1054 @r###"
1055 32..36 'self': A 1055 31..35 'self': A
1056 38..39 'x': u32 1056 37..38 'x': u32
1057 53..55 '{}': () 1057 52..54 '{}': ()
1058 103..107 'self': &A 1058 102..106 'self': &A
1059 109..110 'x': u64 1059 108..109 'x': u64
1060 124..126 '{}': () 1060 123..125 '{}': ()
1061 144..145 'a': A 1061 143..144 'a': A
1062 150..198 '{ ...(1); }': () 1062 149..197 '{ ...(1); }': ()
1063 156..157 'a': A 1063 155..156 'a': A
1064 156..164 'a.foo(1)': i32 1064 155..163 'a.foo(1)': i32
1065 162..163 '1': u32 1065 161..162 '1': u32
1066 170..181 '(&a).bar(1)': i64 1066 169..180 '(&a).bar(1)': i64
1067 171..173 '&a': &A 1067 170..172 '&a': &A
1068 172..173 'a': A 1068 171..172 'a': A
1069 179..180 '1': u64 1069 178..179 '1': u64
1070 187..188 'a': A 1070 186..187 'a': A
1071 187..195 'a.bar(1)': i64 1071 186..194 'a.bar(1)': i64
1072 193..194 '1': u64 1072 192..193 '1': u64
1073 "### 1073 "###
1074 ); 1074 );
1075} 1075}
@@ -1088,11 +1088,11 @@ fn test() {
1088} 1088}
1089"#), 1089"#),
1090 @r###" 1090 @r###"
1091 40..44 'self': &str 1091 39..43 'self': &str
1092 53..55 '{}': () 1092 52..54 '{}': ()
1093 69..89 '{ ...o(); }': () 1093 68..88 '{ ...o(); }': ()
1094 75..80 '"foo"': &str 1094 74..79 '"foo"': &str
1095 75..86 '"foo".foo()': i32 1095 74..85 '"foo".foo()': i32
1096 "### 1096 "###
1097 ); 1097 );
1098} 1098}
@@ -1111,33 +1111,33 @@ fn test(x: &str, y: isize) {
1111} 1111}
1112"#), 1112"#),
1113 @r###" 1113 @r###"
1114 9..10 'x': &str 1114 8..9 'x': &str
1115 18..19 'y': isize 1115 17..18 'y': isize
1116 28..170 '{ ...d"); }': () 1116 27..169 '{ ...d"); }': ()
1117 38..39 'a': (u32, &str) 1117 37..38 'a': (u32, &str)
1118 55..63 '(1, "a")': (u32, &str) 1118 54..62 '(1, "a")': (u32, &str)
1119 56..57 '1': u32 1119 55..56 '1': u32
1120 59..62 '"a"': &str 1120 58..61 '"a"': &str
1121 73..74 'b': ((u32, &str), &str) 1121 72..73 'b': ((u32, &str), &str)
1122 77..83 '(a, x)': ((u32, &str), &str) 1122 76..82 '(a, x)': ((u32, &str), &str)
1123 78..79 'a': (u32, &str) 1123 77..78 'a': (u32, &str)
1124 81..82 'x': &str 1124 80..81 'x': &str
1125 93..94 'c': (isize, &str) 1125 92..93 'c': (isize, &str)
1126 97..103 '(y, x)': (isize, &str) 1126 96..102 '(y, x)': (isize, &str)
1127 98..99 'y': isize 1127 97..98 'y': isize
1128 101..102 'x': &str 1128 100..101 'x': &str
1129 113..114 'd': ((isize, &str), &str) 1129 112..113 'd': ((isize, &str), &str)
1130 117..123 '(c, x)': ((isize, &str), &str) 1130 116..122 '(c, x)': ((isize, &str), &str)
1131 118..119 'c': (isize, &str) 1131 117..118 'c': (isize, &str)
1132 121..122 'x': &str 1132 120..121 'x': &str
1133 133..134 'e': (i32, &str) 1133 132..133 'e': (i32, &str)
1134 137..145 '(1, "e")': (i32, &str) 1134 136..144 '(1, "e")': (i32, &str)
1135 138..139 '1': i32 1135 137..138 '1': i32
1136 141..144 '"e"': &str 1136 140..143 '"e"': &str
1137 155..156 'f': ((i32, &str), &str) 1137 154..155 'f': ((i32, &str), &str)
1138 159..167 '(e, "d")': ((i32, &str), &str) 1138 158..166 '(e, "d")': ((i32, &str), &str)
1139 160..161 'e': (i32, &str) 1139 159..160 'e': (i32, &str)
1140 163..166 '"d"': &str 1140 162..165 '"d"': &str
1141 "### 1141 "###
1142 ); 1142 );
1143} 1143}
@@ -1165,58 +1165,58 @@ fn test(x: &str, y: isize) {
1165} 1165}
1166"#), 1166"#),
1167 @r###" 1167 @r###"
1168 9..10 'x': &str 1168 8..9 'x': &str
1169 18..19 'y': isize 1169 17..18 'y': isize
1170 28..293 '{ ... []; }': () 1170 27..292 '{ ... []; }': ()
1171 38..39 'a': [&str; _] 1171 37..38 'a': [&str; _]
1172 42..45 '[x]': [&str; _] 1172 41..44 '[x]': [&str; _]
1173 43..44 'x': &str 1173 42..43 'x': &str
1174 55..56 'b': [[&str; _]; _] 1174 54..55 'b': [[&str; _]; _]
1175 59..65 '[a, a]': [[&str; _]; _] 1175 58..64 '[a, a]': [[&str; _]; _]
1176 60..61 'a': [&str; _] 1176 59..60 'a': [&str; _]
1177 63..64 'a': [&str; _] 1177 62..63 'a': [&str; _]
1178 75..76 'c': [[[&str; _]; _]; _] 1178 74..75 'c': [[[&str; _]; _]; _]
1179 79..85 '[b, b]': [[[&str; _]; _]; _] 1179 78..84 '[b, b]': [[[&str; _]; _]; _]
1180 80..81 'b': [[&str; _]; _] 1180 79..80 'b': [[&str; _]; _]
1181 83..84 'b': [[&str; _]; _] 1181 82..83 'b': [[&str; _]; _]
1182 96..97 'd': [isize; _] 1182 95..96 'd': [isize; _]
1183 100..112 '[y, 1, 2, 3]': [isize; _] 1183 99..111 '[y, 1, 2, 3]': [isize; _]
1184 101..102 'y': isize 1184 100..101 'y': isize
1185 104..105 '1': isize 1185 103..104 '1': isize
1186 107..108 '2': isize 1186 106..107 '2': isize
1187 110..111 '3': isize 1187 109..110 '3': isize
1188 122..123 'd': [isize; _] 1188 121..122 'd': [isize; _]
1189 126..138 '[1, y, 2, 3]': [isize; _] 1189 125..137 '[1, y, 2, 3]': [isize; _]
1190 127..128 '1': isize 1190 126..127 '1': isize
1191 130..131 'y': isize 1191 129..130 'y': isize
1192 133..134 '2': isize 1192 132..133 '2': isize
1193 136..137 '3': isize 1193 135..136 '3': isize
1194 148..149 'e': [isize; _] 1194 147..148 'e': [isize; _]
1195 152..155 '[y]': [isize; _] 1195 151..154 '[y]': [isize; _]
1196 153..154 'y': isize 1196 152..153 'y': isize
1197 165..166 'f': [[isize; _]; _] 1197 164..165 'f': [[isize; _]; _]
1198 169..175 '[d, d]': [[isize; _]; _] 1198 168..174 '[d, d]': [[isize; _]; _]
1199 170..171 'd': [isize; _] 1199 169..170 'd': [isize; _]
1200 173..174 'd': [isize; _] 1200 172..173 'd': [isize; _]
1201 185..186 'g': [[isize; _]; _] 1201 184..185 'g': [[isize; _]; _]
1202 189..195 '[e, e]': [[isize; _]; _] 1202 188..194 '[e, e]': [[isize; _]; _]
1203 190..191 'e': [isize; _] 1203 189..190 'e': [isize; _]
1204 193..194 'e': [isize; _] 1204 192..193 'e': [isize; _]
1205 206..207 'h': [i32; _] 1205 205..206 'h': [i32; _]
1206 210..216 '[1, 2]': [i32; _] 1206 209..215 '[1, 2]': [i32; _]
1207 211..212 '1': i32 1207 210..211 '1': i32
1208 214..215 '2': i32 1208 213..214 '2': i32
1209 226..227 'i': [&str; _] 1209 225..226 'i': [&str; _]
1210 230..240 '["a", "b"]': [&str; _] 1210 229..239 '["a", "b"]': [&str; _]
1211 231..234 '"a"': &str 1211 230..233 '"a"': &str
1212 236..239 '"b"': &str 1212 235..238 '"b"': &str
1213 251..252 'b': [[&str; _]; _] 1213 250..251 'b': [[&str; _]; _]
1214 255..265 '[a, ["b"]]': [[&str; _]; _] 1214 254..264 '[a, ["b"]]': [[&str; _]; _]
1215 256..257 'a': [&str; _] 1215 255..256 'a': [&str; _]
1216 259..264 '["b"]': [&str; _] 1216 258..263 '["b"]': [&str; _]
1217 260..263 '"b"': &str 1217 259..262 '"b"': &str
1218 275..276 'x': [u8; _] 1218 274..275 'x': [u8; _]
1219 288..290 '[]': [u8; _] 1219 287..289 '[]': [u8; _]
1220 "### 1220 "###
1221 ); 1221 );
1222} 1222}
@@ -1238,21 +1238,21 @@ fn test(a1: A<u32>, i: i32) {
1238} 1238}
1239"#), 1239"#),
1240 @r###" 1240 @r###"
1241 36..38 'a1': A<u32> 1241 35..37 'a1': A<u32>
1242 48..49 'i': i32 1242 47..48 'i': i32
1243 56..147 '{ ...3.x; }': () 1243 55..146 '{ ...3.x; }': ()
1244 62..64 'a1': A<u32> 1244 61..63 'a1': A<u32>
1245 62..66 'a1.x': u32 1245 61..65 'a1.x': u32
1246 76..78 'a2': A<i32> 1246 75..77 'a2': A<i32>
1247 81..91 'A { x: i }': A<i32> 1247 80..90 'A { x: i }': A<i32>
1248 88..89 'i': i32 1248 87..88 'i': i32
1249 97..99 'a2': A<i32> 1249 96..98 'a2': A<i32>
1250 97..101 'a2.x': i32 1250 96..100 'a2.x': i32
1251 111..113 'a3': A<i128> 1251 110..112 'a3': A<i128>
1252 116..134 'A::<i1...x: 1 }': A<i128> 1252 115..133 'A::<i1...x: 1 }': A<i128>
1253 131..132 '1': i128 1253 130..131 '1': i128
1254 140..142 'a3': A<i128> 1254 139..141 'a3': A<i128>
1255 140..144 'a3.x': i128 1255 139..143 'a3.x': i128
1256 "### 1256 "###
1257 ); 1257 );
1258} 1258}
@@ -1275,22 +1275,22 @@ fn test() {
1275} 1275}
1276"#), 1276"#),
1277 @r###" 1277 @r###"
1278 76..184 '{ ...one; }': () 1278 75..183 '{ ...one; }': ()
1279 82..83 'A': A<i32>(i32) -> A<i32> 1279 81..82 'A': A<i32>(i32) -> A<i32>
1280 82..87 'A(42)': A<i32> 1280 81..86 'A(42)': A<i32>
1281 84..86 '42': i32 1281 83..85 '42': i32
1282 93..94 'A': A<u128>(u128) -> A<u128> 1282 92..93 'A': A<u128>(u128) -> A<u128>
1283 93..102 'A(42u128)': A<u128> 1283 92..101 'A(42u128)': A<u128>
1284 95..101 '42u128': u128 1284 94..100 '42u128': u128
1285 108..112 'Some': Some<&str>(&str) -> Option<&str> 1285 107..111 'Some': Some<&str>(&str) -> Option<&str>
1286 108..117 'Some("x")': Option<&str> 1286 107..116 'Some("x")': Option<&str>
1287 113..116 '"x"': &str 1287 112..115 '"x"': &str
1288 123..135 'Option::Some': Some<&str>(&str) -> Option<&str> 1288 122..134 'Option::Some': Some<&str>(&str) -> Option<&str>
1289 123..140 'Option...e("x")': Option<&str> 1289 122..139 'Option...e("x")': Option<&str>
1290 136..139 '"x"': &str 1290 135..138 '"x"': &str
1291 146..150 'None': Option<{unknown}> 1291 145..149 'None': Option<{unknown}>
1292 160..161 'x': Option<i64> 1292 159..160 'x': Option<i64>
1293 177..181 'None': Option<i64> 1293 176..180 'None': Option<i64>
1294 "### 1294 "###
1295 ); 1295 );
1296} 1296}
@@ -1308,20 +1308,20 @@ fn test() {
1308} 1308}
1309"#), 1309"#),
1310 @r###" 1310 @r###"
1311 10..11 't': T 1311 9..10 't': T
1312 21..26 '{ t }': T 1312 20..25 '{ t }': T
1313 23..24 't': T 1313 22..23 't': T
1314 38..98 '{ ...(1); }': () 1314 37..97 '{ ...(1); }': ()
1315 44..46 'id': fn id<u32>(u32) -> u32 1315 43..45 'id': fn id<u32>(u32) -> u32
1316 44..52 'id(1u32)': u32 1316 43..51 'id(1u32)': u32
1317 47..51 '1u32': u32 1317 46..50 '1u32': u32
1318 58..68 'id::<i128>': fn id<i128>(i128) -> i128 1318 57..67 'id::<i128>': fn id<i128>(i128) -> i128
1319 58..71 'id::<i128>(1)': i128 1319 57..70 'id::<i128>(1)': i128
1320 69..70 '1': i128 1320 68..69 '1': i128
1321 81..82 'x': u64 1321 80..81 'x': u64
1322 90..92 'id': fn id<u64>(u64) -> u64 1322 89..91 'id': fn id<u64>(u64) -> u64
1323 90..95 'id(1)': u64 1323 89..94 'id(1)': u64
1324 93..94 '1': u64 1324 92..93 '1': u64
1325 "### 1325 "###
1326 ); 1326 );
1327} 1327}
@@ -1355,38 +1355,38 @@ fn test() -> i128 {
1355} 1355}
1356"#), 1356"#),
1357 @r###" 1357 @r###"
1358 74..78 'self': A<X, Y> 1358 73..77 'self': A<X, Y>
1359 85..107 '{ ... }': X 1359 84..106 '{ ... }': X
1360 95..99 'self': A<X, Y> 1360 94..98 'self': A<X, Y>
1361 95..101 'self.x': X 1361 94..100 'self.x': X
1362 117..121 'self': A<X, Y> 1362 116..120 'self': A<X, Y>
1363 128..150 '{ ... }': Y 1363 127..149 '{ ... }': Y
1364 138..142 'self': A<X, Y> 1364 137..141 'self': A<X, Y>
1365 138..144 'self.y': Y 1365 137..143 'self.y': Y
1366 163..167 'self': A<X, Y> 1366 162..166 'self': A<X, Y>
1367 169..170 't': T 1367 168..169 't': T
1368 188..223 '{ ... }': (X, Y, T) 1368 187..222 '{ ... }': (X, Y, T)
1369 198..217 '(self.....y, t)': (X, Y, T) 1369 197..216 '(self.....y, t)': (X, Y, T)
1370 199..203 'self': A<X, Y> 1370 198..202 'self': A<X, Y>
1371 199..205 'self.x': X 1371 198..204 'self.x': X
1372 207..211 'self': A<X, Y> 1372 206..210 'self': A<X, Y>
1373 207..213 'self.y': Y 1373 206..212 'self.y': Y
1374 215..216 't': T 1374 214..215 't': T
1375 245..342 '{ ...(1); }': () 1375 244..341 '{ ...(1); }': ()
1376 255..256 'a': A<u64, i64> 1376 254..255 'a': A<u64, i64>
1377 259..281 'A { x:...1i64 }': A<u64, i64> 1377 258..280 'A { x:...1i64 }': A<u64, i64>
1378 266..270 '1u64': u64 1378 265..269 '1u64': u64
1379 275..279 '1i64': i64 1379 274..278 '1i64': i64
1380 287..288 'a': A<u64, i64> 1380 286..287 'a': A<u64, i64>
1381 287..292 'a.x()': u64 1381 286..291 'a.x()': u64
1382 298..299 'a': A<u64, i64> 1382 297..298 'a': A<u64, i64>
1383 298..303 'a.y()': i64 1383 297..302 'a.y()': i64
1384 309..310 'a': A<u64, i64> 1384 308..309 'a': A<u64, i64>
1385 309..319 'a.z(1i128)': (u64, i64, i128) 1385 308..318 'a.z(1i128)': (u64, i64, i128)
1386 313..318 '1i128': i128 1386 312..317 '1i128': i128
1387 325..326 'a': A<u64, i64> 1387 324..325 'a': A<u64, i64>
1388 325..339 'a.z::<u128>(1)': (u64, i64, u128) 1388 324..338 'a.z::<u128>(1)': (u64, i64, u128)
1389 337..338 '1': u128 1389 336..337 '1': u128
1390 "### 1390 "###
1391 ); 1391 );
1392} 1392}
@@ -1408,15 +1408,15 @@ fn test(o: Option<u32>) {
1408} 1408}
1409"#), 1409"#),
1410 @r###" 1410 @r###"
1411 78..82 'self': &Option<T> 1411 77..81 'self': &Option<T>
1412 98..100 '{}': () 1412 97..99 '{}': ()
1413 111..112 'o': Option<u32> 1413 110..111 'o': Option<u32>
1414 127..165 '{ ...f(); }': () 1414 126..164 '{ ...f(); }': ()
1415 133..146 '(&o).as_ref()': Option<&u32> 1415 132..145 '(&o).as_ref()': Option<&u32>
1416 134..136 '&o': &Option<u32> 1416 133..135 '&o': &Option<u32>
1417 135..136 'o': Option<u32> 1417 134..135 'o': Option<u32>
1418 152..153 'o': Option<u32> 1418 151..152 'o': Option<u32>
1419 152..162 'o.as_ref()': Option<&u32> 1419 151..161 'o.as_ref()': Option<&u32>
1420 "### 1420 "###
1421 ); 1421 );
1422} 1422}
@@ -1445,35 +1445,35 @@ fn test() -> i128 {
1445} 1445}
1446"#), 1446"#),
1447 @r###" 1447 @r###"
1448 53..57 'self': A<T2> 1448 52..56 'self': A<T2>
1449 65..87 '{ ... }': T2 1449 64..86 '{ ... }': T2
1450 75..79 'self': A<T2> 1450 74..78 'self': A<T2>
1451 75..81 'self.x': T2 1451 74..80 'self.x': T2
1452 99..100 't': T 1452 98..99 't': T
1453 110..115 '{ t }': T 1453 109..114 '{ t }': T
1454 112..113 't': T 1454 111..112 't': T
1455 135..261 '{ ....x() }': i128 1455 134..260 '{ ....x() }': i128
1456 146..147 'x': i128 1456 145..146 'x': i128
1457 150..151 '1': i128 1457 149..150 '1': i128
1458 162..163 'y': i128 1458 161..162 'y': i128
1459 166..168 'id': fn id<i128>(i128) -> i128 1459 165..167 'id': fn id<i128>(i128) -> i128
1460 166..171 'id(x)': i128 1460 165..170 'id(x)': i128
1461 169..170 'x': i128 1461 168..169 'x': i128
1462 182..183 'a': A<i128> 1462 181..182 'a': A<i128>
1463 186..200 'A { x: id(y) }': A<i128> 1463 185..199 'A { x: id(y) }': A<i128>
1464 193..195 'id': fn id<i128>(i128) -> i128 1464 192..194 'id': fn id<i128>(i128) -> i128
1465 193..198 'id(y)': i128 1465 192..197 'id(y)': i128
1466 196..197 'y': i128 1466 195..196 'y': i128
1467 211..212 'z': i128 1467 210..211 'z': i128
1468 215..217 'id': fn id<i128>(i128) -> i128 1468 214..216 'id': fn id<i128>(i128) -> i128
1469 215..222 'id(a.x)': i128 1469 214..221 'id(a.x)': i128
1470 218..219 'a': A<i128> 1470 217..218 'a': A<i128>
1471 218..221 'a.x': i128 1471 217..220 'a.x': i128
1472 233..234 'b': A<i128> 1472 232..233 'b': A<i128>
1473 237..247 'A { x: z }': A<i128> 1473 236..246 'A { x: z }': A<i128>
1474 244..245 'z': i128 1474 243..244 'z': i128
1475 254..255 'b': A<i128> 1475 253..254 'b': A<i128>
1476 254..259 'b.x()': i128 1476 253..258 'b.x()': i128
1477 "### 1477 "###
1478 ); 1478 );
1479} 1479}
@@ -1511,16 +1511,16 @@ fn test() {
1511} 1511}
1512"#), 1512"#),
1513 @r###" 1513 @r###"
1514 52..53 '1': u32 1514 51..52 '1': u32
1515 105..106 '2': u32 1515 104..105 '2': u32
1516 213..214 '5': u32 1516 212..213 '5': u32
1517 229..307 '{ ...:ID; }': () 1517 228..306 '{ ...:ID; }': ()
1518 239..240 'x': u32 1518 238..239 'x': u32
1519 243..254 'Struct::FOO': u32 1519 242..253 'Struct::FOO': u32
1520 264..265 'y': u32 1520 263..264 'y': u32
1521 268..277 'Enum::BAR': u32 1521 267..276 'Enum::BAR': u32
1522 287..288 'z': u32 1522 286..287 'z': u32
1523 291..304 'TraitTest::ID': u32 1523 290..303 'TraitTest::ID': u32
1524 "### 1524 "###
1525 ); 1525 );
1526} 1526}
@@ -1543,22 +1543,22 @@ fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
1543} 1543}
1544"#), 1544"#),
1545 @r###" 1545 @r###"
1546 116..117 'x': A<u32, i128> 1546 115..116 'x': A<u32, i128>
1547 124..125 'y': A<&str, u128> 1547 123..124 'y': A<&str, u128>
1548 138..139 'z': A<u8, i8> 1548 137..138 'z': A<u8, i8>
1549 154..211 '{ ...z.y; }': () 1549 153..210 '{ ...z.y; }': ()
1550 160..161 'x': A<u32, i128> 1550 159..160 'x': A<u32, i128>
1551 160..163 'x.x': u32 1551 159..162 'x.x': u32
1552 169..170 'x': A<u32, i128> 1552 168..169 'x': A<u32, i128>
1553 169..172 'x.y': i128 1553 168..171 'x.y': i128
1554 178..179 'y': A<&str, u128> 1554 177..178 'y': A<&str, u128>
1555 178..181 'y.x': &str 1555 177..180 'y.x': &str
1556 187..188 'y': A<&str, u128> 1556 186..187 'y': A<&str, u128>
1557 187..190 'y.y': u128 1557 186..189 'y.y': u128
1558 196..197 'z': A<u8, i8> 1558 195..196 'z': A<u8, i8>
1559 196..199 'z.x': u8 1559 195..198 'z.x': u8
1560 205..206 'z': A<u8, i8> 1560 204..205 'z': A<u8, i8>
1561 205..208 'z.y': i8 1561 204..207 'z.y': i8
1562 "### 1562 "###
1563 ) 1563 )
1564} 1564}
@@ -1573,8 +1573,8 @@ type Bar = A<Bar>;
1573fn test(x: Foo) {} 1573fn test(x: Foo) {}
1574"#), 1574"#),
1575 @r###" 1575 @r###"
1576 59..60 'x': {unknown} 1576 58..59 'x': {unknown}
1577 67..69 '{}': () 1577 66..68 '{}': ()
1578 "### 1578 "###
1579 ) 1579 )
1580} 1580}
@@ -1599,26 +1599,26 @@ fn test() {
1599} 1599}
1600"#), 1600"#),
1601 @r###" 1601 @r###"
1602 10..11 'x': T 1602 9..10 'x': T
1603 21..30 '{ x }': T 1603 20..29 '{ x }': T
1604 27..28 'x': T 1604 26..27 'x': T
1605 44..45 'x': &T 1605 43..44 'x': &T
1606 56..66 '{ *x }': T 1606 55..65 '{ *x }': T
1607 62..64 '*x': T 1607 61..63 '*x': T
1608 63..64 'x': &T 1608 62..63 'x': &T
1609 78..158 '{ ...(1); }': () 1609 77..157 '{ ...(1); }': ()
1610 88..89 'y': u32 1610 87..88 'y': u32
1611 92..97 '10u32': u32 1611 91..96 '10u32': u32
1612 103..105 'id': fn id<u32>(u32) -> u32 1612 102..104 'id': fn id<u32>(u32) -> u32
1613 103..108 'id(y)': u32 1613 102..107 'id(y)': u32
1614 106..107 'y': u32 1614 105..106 'y': u32
1615 118..119 'x': bool 1615 117..118 'x': bool
1616 128..133 'clone': fn clone<bool>(&bool) -> bool 1616 127..132 'clone': fn clone<bool>(&bool) -> bool
1617 128..136 'clone(z)': bool 1617 127..135 'clone(z)': bool
1618 134..135 'z': &bool 1618 133..134 'z': &bool
1619 142..152 'id::<i128>': fn id<i128>(i128) -> i128 1619 141..151 'id::<i128>': fn id<i128>(i128) -> i128
1620 142..155 'id::<i128>(1)': i128 1620 141..154 'id::<i128>(1)': i128
1621 153..154 '1': i128 1621 152..153 '1': i128
1622 "### 1622 "###
1623 ); 1623 );
1624} 1624}
@@ -1638,16 +1638,16 @@ fn test() {
1638} 1638}
1639"#), 1639"#),
1640 @r###" 1640 @r###"
1641 49..50 '0': u32 1641 48..49 '0': u32
1642 80..83 '101': u32 1642 79..82 '101': u32
1643 95..213 '{ ...NST; }': () 1643 94..212 '{ ...NST; }': ()
1644 138..139 'x': u32 1644 137..138 'x': u32
1645 142..153 'LOCAL_CONST': u32 1645 141..152 'LOCAL_CONST': u32
1646 163..164 'z': u32 1646 162..163 'z': u32
1647 167..179 'GLOBAL_CONST': u32 1647 166..178 'GLOBAL_CONST': u32
1648 189..191 'id': u32 1648 188..190 'id': u32
1649 194..210 'Foo::A..._CONST': u32 1649 193..209 'Foo::A..._CONST': u32
1650 126..128 '99': u32 1650 125..127 '99': u32
1651 "### 1651 "###
1652 ); 1652 );
1653} 1653}
@@ -1668,19 +1668,19 @@ fn test() {
1668} 1668}
1669"#), 1669"#),
1670 @r###" 1670 @r###"
1671 29..32 '101': u32 1671 28..31 '101': u32
1672 70..73 '101': u32 1672 69..72 '101': u32
1673 85..280 '{ ...MUT; }': () 1673 84..279 '{ ...MUT; }': ()
1674 173..174 'x': u32 1674 172..173 'x': u32
1675 177..189 'LOCAL_STATIC': u32 1675 176..188 'LOCAL_STATIC': u32
1676 199..200 'y': u32 1676 198..199 'y': u32
1677 203..219 'LOCAL_...IC_MUT': u32 1677 202..218 'LOCAL_...IC_MUT': u32
1678 229..230 'z': u32 1678 228..229 'z': u32
1679 233..246 'GLOBAL_STATIC': u32 1679 232..245 'GLOBAL_STATIC': u32
1680 256..257 'w': u32 1680 255..256 'w': u32
1681 260..277 'GLOBAL...IC_MUT': u32 1681 259..276 'GLOBAL...IC_MUT': u32
1682 118..120 '99': u32 1682 117..119 '99': u32
1683 161..163 '99': u32 1683 160..162 '99': u32
1684 "### 1684 "###
1685 ); 1685 );
1686} 1686}
@@ -1748,12 +1748,12 @@ fn foo() -> u32 {
1748} 1748}
1749"#), 1749"#),
1750 @r###" 1750 @r###"
1751 17..59 '{ ...; }; }': () 1751 16..58 '{ ...; }; }': ()
1752 27..28 'x': || -> usize 1752 26..27 'x': || -> usize
1753 31..56 '|| -> ...n 1; }': || -> usize 1753 30..55 '|| -> ...n 1; }': || -> usize
1754 43..56 '{ return 1; }': usize 1754 42..55 '{ return 1; }': usize
1755 45..53 'return 1': ! 1755 44..52 'return 1': !
1756 52..53 '1': usize 1756 51..52 '1': usize
1757 "### 1757 "###
1758 ); 1758 );
1759} 1759}
@@ -1767,11 +1767,11 @@ fn foo() -> u32 {
1767} 1767}
1768"#), 1768"#),
1769 @r###" 1769 @r###"
1770 17..48 '{ ...; }; }': () 1770 16..47 '{ ...; }; }': ()
1771 27..28 'x': || -> () 1771 26..27 'x': || -> ()
1772 31..45 '|| { return; }': || -> () 1772 30..44 '|| { return; }': || -> ()
1773 34..45 '{ return; }': () 1773 33..44 '{ return; }': ()
1774 36..42 'return': ! 1774 35..41 'return': !
1775 "### 1775 "###
1776 ); 1776 );
1777} 1777}
@@ -1785,11 +1785,11 @@ fn foo() -> u32 {
1785} 1785}
1786"#), 1786"#),
1787 @r###" 1787 @r###"
1788 17..47 '{ ..." }; }': () 1788 16..46 '{ ..." }; }': ()
1789 27..28 'x': || -> &str 1789 26..27 'x': || -> &str
1790 31..44 '|| { "test" }': || -> &str 1790 30..43 '|| { "test" }': || -> &str
1791 34..44 '{ "test" }': &str 1791 33..43 '{ "test" }': &str
1792 36..42 '"test"': &str 1792 35..41 '"test"': &str
1793 "### 1793 "###
1794 ); 1794 );
1795} 1795}
@@ -1808,14 +1808,14 @@ fn main() {
1808} 1808}
1809"#), 1809"#),
1810 @r###" 1810 @r###"
1811 48..121 '{ ...hod; }': () 1811 47..120 '{ ...hod; }': ()
1812 58..64 'vtable': Vtable 1812 57..63 'vtable': Vtable
1813 67..91 'Vtable...| {} }': Vtable 1813 66..90 'Vtable...| {} }': Vtable
1814 84..89 '|| {}': || -> () 1814 83..88 '|| {}': || -> ()
1815 87..89 '{}': () 1815 86..88 '{}': ()
1816 101..102 'm': fn() 1816 100..101 'm': fn()
1817 105..111 'vtable': Vtable 1817 104..110 'vtable': Vtable
1818 105..118 'vtable.method': fn() 1818 104..117 'vtable.method': fn()
1819 "### 1819 "###
1820 ); 1820 );
1821} 1821}
@@ -1832,22 +1832,22 @@ fn main() {
1832} 1832}
1833"#), 1833"#),
1834 @r###" 1834 @r###"
1835 11..131 '{ ...2 }; }': () 1835 10..130 '{ ...2 }; }': ()
1836 21..22 'x': i32 1836 20..21 'x': i32
1837 32..38 '{ 92 }': i32 1837 31..37 '{ 92 }': i32
1838 34..36 '92': i32 1838 33..35 '92': i32
1839 48..49 'y': {unknown} 1839 47..48 'y': {unknown}
1840 58..80 '{ asyn...wait }': {unknown} 1840 57..79 '{ asyn...wait }': {unknown}
1841 60..78 'async ....await': {unknown} 1841 59..77 'async ....await': {unknown}
1842 66..72 '{ () }': () 1842 65..71 '{ () }': ()
1843 68..70 '()': () 1843 67..69 '()': ()
1844 90..91 'z': {unknown} 1844 89..90 'z': {unknown}
1845 94..104 'try { () }': {unknown} 1845 93..103 'try { () }': {unknown}
1846 98..104 '{ () }': () 1846 97..103 '{ () }': ()
1847 100..102 '()': () 1847 99..101 '()': ()
1848 114..115 't': i32 1848 113..114 't': i32
1849 122..128 '{ 92 }': i32 1849 121..127 '{ 92 }': i32
1850 124..126 '92': i32 1850 123..125 '92': i32
1851 "### 1851 "###
1852 ) 1852 )
1853} 1853}
@@ -1867,16 +1867,16 @@ fn test() {
1867} 1867}
1868"#), 1868"#),
1869 @r###" 1869 @r###"
1870 60..130 '{ ... } }': () 1870 59..129 '{ ... } }': ()
1871 70..77 'mut end': Option<bool> 1871 69..76 'mut end': Option<bool>
1872 80..84 'None': Option<bool> 1872 79..83 'None': Option<bool>
1873 90..128 'loop {... }': ! 1873 89..127 'loop {... }': !
1874 95..128 '{ ... }': () 1874 94..127 '{ ... }': ()
1875 105..108 'end': Option<bool> 1875 104..107 'end': Option<bool>
1876 105..121 'end = ...(true)': () 1876 104..120 'end = ...(true)': ()
1877 111..115 'Some': Some<bool>(bool) -> Option<bool> 1877 110..114 'Some': Some<bool>(bool) -> Option<bool>
1878 111..121 'Some(true)': Option<bool> 1878 110..120 'Some(true)': Option<bool>
1879 116..120 'true': bool 1879 115..119 'true': bool
1880 "### 1880 "###
1881 ); 1881 );
1882} 1882}
@@ -1899,19 +1899,19 @@ fn test() {
1899} 1899}
1900"#), 1900"#),
1901 @r###" 1901 @r###"
1902 60..169 '{ ... }; }': () 1902 59..168 '{ ... }; }': ()
1903 70..71 'x': Option<bool> 1903 69..70 'x': Option<bool>
1904 74..166 'loop {... }': Option<bool> 1904 73..165 'loop {... }': Option<bool>
1905 79..166 '{ ... }': () 1905 78..165 '{ ... }': ()
1906 89..133 'if fal... }': () 1906 88..132 'if fal... }': ()
1907 92..97 'false': bool 1907 91..96 'false': bool
1908 98..133 '{ ... }': () 1908 97..132 '{ ... }': ()
1909 112..122 'break None': ! 1909 111..121 'break None': !
1910 118..122 'None': Option<bool> 1910 117..121 'None': Option<bool>
1911 143..159 'break ...(true)': ! 1911 142..158 'break ...(true)': !
1912 149..153 'Some': Some<bool>(bool) -> Option<bool> 1912 148..152 'Some': Some<bool>(bool) -> Option<bool>
1913 149..159 'Some(true)': Option<bool> 1913 148..158 'Some(true)': Option<bool>
1914 154..158 'true': bool 1914 153..157 'true': bool
1915 "### 1915 "###
1916 ); 1916 );
1917} 1917}
@@ -1932,14 +1932,14 @@ fn test() {
1932} 1932}
1933"#), 1933"#),
1934 @r###" 1934 @r###"
1935 60..137 '{ ... }; }': () 1935 59..136 '{ ... }; }': ()
1936 70..71 'x': () 1936 69..70 'x': ()
1937 74..134 'loop {... }': () 1937 73..133 'loop {... }': ()
1938 79..134 '{ ... }': () 1938 78..133 '{ ... }': ()
1939 89..128 'if fal... }': () 1939 88..127 'if fal... }': ()
1940 92..97 'false': bool 1940 91..96 'false': bool
1941 98..128 '{ ... }': () 1941 97..127 '{ ... }': ()
1942 112..117 'break': ! 1942 111..116 'break': !
1943 "### 1943 "###
1944 ); 1944 );
1945} 1945}
@@ -1964,36 +1964,36 @@ fn foo() {
1964} 1964}
1965"#), 1965"#),
1966 @r###" 1966 @r###"
1967 10..336 '{ ... }; }': () 1967 9..335 '{ ... }; }': ()
1968 20..22 '_x': || -> bool 1968 19..21 '_x': || -> bool
1969 25..333 '|| 'ou... }': || -> bool 1969 24..332 '|| 'ou... }': || -> bool
1970 28..333 ''outer... }': bool 1970 27..332 ''outer... }': bool
1971 41..333 '{ ... }': () 1971 40..332 '{ ... }': ()
1972 55..60 'inner': i8 1972 54..59 'inner': i8
1973 63..301 ''inner... }': i8 1973 62..300 ''inner... }': i8
1974 76..301 '{ ... }': () 1974 75..300 '{ ... }': ()
1975 94..95 'i': bool 1975 93..94 'i': bool
1976 98..114 'Defaul...efault': {unknown} 1976 97..113 'Defaul...efault': {unknown}
1977 98..116 'Defaul...ault()': bool 1977 97..115 'Defaul...ault()': bool
1978 130..270 'if (br... }': () 1978 129..269 'if (br... }': ()
1979 134..148 'break 'outer i': ! 1979 133..147 'break 'outer i': !
1980 147..148 'i': bool 1980 146..147 'i': bool
1981 150..209 '{ ... }': () 1981 149..208 '{ ... }': ()
1982 168..194 'loop {...5i8; }': ! 1982 167..193 'loop {...5i8; }': !
1983 173..194 '{ brea...5i8; }': () 1983 172..193 '{ brea...5i8; }': ()
1984 175..191 'break ...er 5i8': ! 1984 174..190 'break ...er 5i8': !
1985 188..191 '5i8': i8 1985 187..190 '5i8': i8
1986 215..270 'if tru... }': () 1986 214..269 'if tru... }': ()
1987 218..222 'true': bool 1987 217..221 'true': bool
1988 223..270 '{ ... }': () 1988 222..269 '{ ... }': ()
1989 241..255 'break 'inner 6': ! 1989 240..254 'break 'inner 6': !
1990 254..255 '6': i8 1990 253..254 '6': i8
1991 283..290 'break 7': ! 1991 282..289 'break 7': !
1992 289..290 '7': i8 1992 288..289 '7': i8
1993 311..326 'break inner < 8': ! 1993 310..325 'break inner < 8': !
1994 317..322 'inner': i8 1994 316..321 'inner': i8
1995 317..326 'inner < 8': bool 1995 316..325 'inner < 8': bool
1996 325..326 '8': i8 1996 324..325 '8': i8
1997 "### 1997 "###
1998 ); 1998 );
1999} 1999}
@@ -2022,35 +2022,35 @@ fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) {
2022} 2022}
2023"#), 2023"#),
2024 @r###" 2024 @r###"
2025 98..100 't1': Thing<()> 2025 97..99 't1': Thing<()>
2026 109..111 't2': OtherThing<()> 2026 108..110 't2': OtherThing<()>
2027 125..127 't3': Thing<i32> 2027 124..126 't3': Thing<i32>
2028 141..143 't4': OtherThing<i32> 2028 140..142 't4': OtherThing<i32>
2029 162..385 '{ ... } }': () 2029 161..384 '{ ... } }': ()
2030 168..170 't1': Thing<()> 2030 167..169 't1': Thing<()>
2031 168..172 't1.t': () 2031 167..171 't1.t': ()
2032 178..180 't3': Thing<i32> 2032 177..179 't3': Thing<i32>
2033 178..182 't3.t': i32 2033 177..181 't3.t': i32
2034 188..283 'match ... }': () 2034 187..282 'match ... }': ()
2035 194..196 't2': OtherThing<()> 2035 193..195 't2': OtherThing<()>
2036 207..228 'OtherT... { t }': OtherThing<()> 2036 206..227 'OtherT... { t }': OtherThing<()>
2037 225..226 't': () 2037 224..225 't': ()
2038 232..238 '{ t; }': () 2038 231..237 '{ t; }': ()
2039 234..235 't': () 2039 233..234 't': ()
2040 248..266 'OtherT...Two(t)': OtherThing<()> 2040 247..265 'OtherT...Two(t)': OtherThing<()>
2041 264..265 't': () 2041 263..264 't': ()
2042 270..276 '{ t; }': () 2042 269..275 '{ t; }': ()
2043 272..273 't': () 2043 271..272 't': ()
2044 288..383 'match ... }': () 2044 287..382 'match ... }': ()
2045 294..296 't4': OtherThing<i32> 2045 293..295 't4': OtherThing<i32>
2046 307..328 'OtherT... { t }': OtherThing<i32> 2046 306..327 'OtherT... { t }': OtherThing<i32>
2047 325..326 't': i32 2047 324..325 't': i32
2048 332..338 '{ t; }': () 2048 331..337 '{ t; }': ()
2049 334..335 't': i32 2049 333..334 't': i32
2050 348..366 'OtherT...Two(t)': OtherThing<i32> 2050 347..365 'OtherT...Two(t)': OtherThing<i32>
2051 364..365 't': i32 2051 363..364 't': i32
2052 370..376 '{ t; }': () 2052 369..375 '{ t; }': ()
2053 372..373 't': i32 2053 371..372 't': i32
2054 "### 2054 "###
2055 ); 2055 );
2056} 2056}
@@ -2078,30 +2078,30 @@ fn test() {
2078} 2078}
2079"#), 2079"#),
2080 @r###" 2080 @r###"
2081 100..320 '{ ...32); }': () 2081 99..319 '{ ...32); }': ()
2082 110..111 'x': Thing<!> 2082 109..110 'x': Thing<!>
2083 114..134 'Thing ...p {} }': Thing<!> 2083 113..133 'Thing ...p {} }': Thing<!>
2084 125..132 'loop {}': ! 2084 124..131 'loop {}': !
2085 130..132 '{}': () 2085 129..131 '{}': ()
2086 144..145 'y': Thing<()> 2086 143..144 'y': Thing<()>
2087 148..163 'Thing { t: () }': Thing<()> 2087 147..162 'Thing { t: () }': Thing<()>
2088 159..161 '()': () 2088 158..160 '()': ()
2089 173..174 'z': Thing<i32> 2089 172..173 'z': Thing<i32>
2090 177..194 'Thing ...1i32 }': Thing<i32> 2090 176..193 'Thing ...1i32 }': Thing<i32>
2091 188..192 '1i32': i32 2091 187..191 '1i32': i32
2092 200..241 'if let... }': () 2092 199..240 'if let... }': ()
2093 207..218 'Thing { t }': Thing<i32> 2093 206..217 'Thing { t }': Thing<i32>
2094 215..216 't': i32 2094 214..215 't': i32
2095 221..222 'z': Thing<i32> 2095 220..221 'z': Thing<i32>
2096 223..241 '{ ... }': () 2096 222..240 '{ ... }': ()
2097 233..234 't': i32 2097 232..233 't': i32
2098 251..252 'a': OtherThing<i32> 2098 250..251 'a': OtherThing<i32>
2099 255..282 'OtherT...1i32 }': OtherThing<i32> 2099 254..281 'OtherT...1i32 }': OtherThing<i32>
2100 276..280 '1i32': i32 2100 275..279 '1i32': i32
2101 292..293 'b': OtherThing<i32> 2101 291..292 'b': OtherThing<i32>
2102 296..311 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32> 2102 295..310 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
2103 296..317 'OtherT...(1i32)': OtherThing<i32> 2103 295..316 'OtherT...(1i32)': OtherThing<i32>
2104 312..316 '1i32': i32 2104 311..315 '1i32': i32
2105 "### 2105 "###
2106 ); 2106 );
2107} 2107}