Convert tests to text-size

1 files changed, 553 insertions, 553 deletions

diff --git a/crates/ra_hir_ty/src/tests/traits.rs b/crates/ra_hir_ty/src/tests/traits.rs
index a46f03b7f..f51cdd496 100644
--- a/crates/ra_hir_ty/src/tests/traits.rs
+++ b/crates/ra_hir_ty/src/tests/traits.rs
@@ -256,16 +256,16 @@ fn test() {
 }
 "#),
         @r###"
-    [86; 87) 't': T
-    [92; 94) '{}': ()
-    [105; 144) '{     ...(s); }': ()
-    [115; 116) 's': S<u32>
-    [119; 120) 'S': S<u32>(u32) -> S<u32>
-    [119; 129) 'S(unknown)': S<u32>
-    [121; 128) 'unknown': u32
-    [135; 138) 'foo': fn foo<S<u32>>(S<u32>)
-    [135; 141) 'foo(s)': ()
-    [139; 140) 's': S<u32>
+    86..87 't': T
+    92..94 '{}': ()
+    105..144 '{     ...(s); }': ()
+    115..116 's': S<u32>
+    119..120 'S': S<u32>(u32) -> S<u32>
+    119..129 'S(unknown)': S<u32>
+    121..128 'unknown': u32
+    135..138 'foo': fn foo<S<u32>>(S<u32>)
+    135..141 'foo(s)': ()
+    139..140 's': S<u32>
     "###
     );
 }
@@ -284,17 +284,17 @@ fn test() {
 }
 "#),
         @r###"
-    [87; 88) 't': T
-    [98; 100) '{}': ()
-    [111; 163) '{     ...(s); }': ()
-    [121; 122) 's': S<u32>
-    [125; 126) 'S': S<u32>(u32) -> S<u32>
-    [125; 135) 'S(unknown)': S<u32>
-    [127; 134) 'unknown': u32
-    [145; 146) 'x': u32
-    [154; 157) 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
-    [154; 160) 'foo(s)': u32
-    [158; 159) 's': S<u32>
+    87..88 't': T
+    98..100 '{}': ()
+    111..163 '{     ...(s); }': ()
+    121..122 's': S<u32>
+    125..126 'S': S<u32>(u32) -> S<u32>
+    125..135 'S(unknown)': S<u32>
+    127..134 'unknown': u32
+    145..146 'x': u32
+    154..157 'foo': fn foo<u32, S<u32>>(S<u32>) -> u32
+    154..160 'foo(s)': u32
+    158..159 's': S<u32>
     "###
     );
 }
@@ -312,12 +312,12 @@ trait Trait {
 }
 "#),
         @r###"
-    [27; 31) 'self': &Self
-    [53; 57) 'self': &Self
-    [62; 97) '{     ...     }': ()
-    [76; 77) 'x': i64
-    [80; 84) 'self': &Self
-    [80; 90) 'self.foo()': i64
+    27..31 'self': &Self
+    53..57 'self': &Self
+    62..97 '{     ...     }': ()
+    76..77 'x': i64
+    80..84 'self': &Self
+    80..90 'self.foo()': i64
     "###
     );
 }
@@ -337,12 +337,12 @@ trait Trait: SuperTrait {
 }
 "#),
         @r###"
-    [32; 36) 'self': &Self
-    [86; 90) 'self': &Self
-    [95; 130) '{     ...     }': ()
-    [109; 110) 'x': i64
-    [113; 117) 'self': &Self
-    [113; 123) 'self.foo()': i64
+    32..36 'self': &Self
+    86..90 'self': &Self
+    95..130 '{     ...     }': ()
+    109..110 'x': i64
+    113..117 'self': &Self
+    113..123 'self.foo()': i64
     "###
     );
 }
@@ -364,15 +364,15 @@ fn test<T: Iterable>() {
 }
 "#),
         @r###"
-    [108; 261) '{     ...ter; }': ()
-    [118; 119) 'x': u32
-    [145; 146) '1': u32
-    [156; 157) 'y': Iterable::Item<T>
-    [183; 192) 'no_matter': Iterable::Item<T>
-    [202; 203) 'z': Iterable::Item<T>
-    [215; 224) 'no_matter': Iterable::Item<T>
-    [234; 235) 'a': Iterable::Item<T>
-    [249; 258) 'no_matter': Iterable::Item<T>
+    108..261 '{     ...ter; }': ()
+    118..119 'x': u32
+    145..146 '1': u32
+    156..157 'y': Iterable::Item<T>
+    183..192 'no_matter': Iterable::Item<T>
+    202..203 'z': Iterable::Item<T>
+    215..224 'no_matter': Iterable::Item<T>
+    234..235 'a': Iterable::Item<T>
+    249..258 'no_matter': Iterable::Item<T>
     "###
     );
 }
@@ -396,25 +396,25 @@ fn test() {
 }
 "#),
         @r###"
-    [106; 107) 't': T
-    [123; 125) '{}': ()
-    [147; 148) 't': T
-    [178; 180) '{}': ()
-    [202; 203) 't': T
-    [221; 223) '{}': ()
-    [234; 300) '{     ...(S); }': ()
-    [244; 245) 'x': u32
-    [248; 252) 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
-    [248; 255) 'foo1(S)': u32
-    [253; 254) 'S': S
-    [265; 266) 'y': u32
-    [269; 273) 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
-    [269; 276) 'foo2(S)': u32
-    [274; 275) 'S': S
-    [286; 287) 'z': u32
-    [290; 294) 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
-    [290; 297) 'foo3(S)': u32
-    [295; 296) 'S': S
+    106..107 't': T
+    123..125 '{}': ()
+    147..148 't': T
+    178..180 '{}': ()
+    202..203 't': T
+    221..223 '{}': ()
+    234..300 '{     ...(S); }': ()
+    244..245 'x': u32
+    248..252 'foo1': fn foo1<S>(S) -> <S as Iterable>::Item
+    248..255 'foo1(S)': u32
+    253..254 'S': S
+    265..266 'y': u32
+    269..273 'foo2': fn foo2<S>(S) -> <S as Iterable>::Item
+    269..276 'foo2(S)': u32
+    274..275 'S': S
+    286..287 'z': u32
+    290..294 'foo3': fn foo3<S>(S) -> <S as Iterable>::Item
+    290..297 'foo3(S)': u32
+    295..296 'S': S
     "###
     );
 }
@@ -431,9 +431,9 @@ fn test<T: Iterable<Item=u32>>() {
 }
 "#),
         @r###"
-    [67; 100) '{     ...own; }': ()
-    [77; 78) 'y': u32
-    [90; 97) 'unknown': u32
+    67..100 '{     ...own; }': ()
+    77..78 'y': u32
+    90..97 'unknown': u32
     "###
     );
 }
@@ -446,13 +446,13 @@ const A: u32 = 1 + 1;
 static B: u64 = { let x = 1; x };
 "#),
         @r###"
-    [16; 17) '1': u32
-    [16; 21) '1 + 1': u32
-    [20; 21) '1': u32
-    [39; 55) '{ let ...1; x }': u64
-    [45; 46) 'x': u64
-    [49; 50) '1': u64
-    [52; 53) 'x': u64
+    16..17 '1': u32
+    16..21 '1 + 1': u32
+    20..21 '1': u32
+    39..55 '{ let ...1; x }': u64
+    45..46 'x': u64
+    49..50 '1': u64
+    52..53 'x': u64
     "###
     );
 }
@@ -469,17 +469,17 @@ fn test() -> u64 {
 }
 "#),
         @r###"
-    [38; 87) '{     ... a.1 }': u64
-    [48; 49) 'a': S
-    [52; 53) 'S': S(i32, u64) -> S
-    [52; 59) 'S(4, 6)': S
-    [54; 55) '4': i32
-    [57; 58) '6': u64
-    [69; 70) 'b': i32
-    [73; 74) 'a': S
-    [73; 76) 'a.0': i32
-    [82; 83) 'a': S
-    [82; 85) 'a.1': u64
+    38..87 '{     ... a.1 }': u64
+    48..49 'a': S
+    52..53 'S': S(i32, u64) -> S
+    52..59 'S(4, 6)': S
+    54..55 '4': i32
+    57..58 '6': u64
+    69..70 'b': i32
+    73..74 'a': S
+    73..76 'a.0': i32
+    82..83 'a': S
+    82..85 'a.1': u64
     "###
     );
 }
@@ -496,24 +496,24 @@ fn test() -> u64 {
 }
 "#),
         @r###"
-    [44; 102) '{     ...0(2) }': u64
-    [54; 55) 'a': S
-    [58; 59) 'S': S(fn(u32) -> u64) -> S
-    [58; 68) 'S(|i| 2*i)': S
-    [60; 67) '|i| 2*i': |u32| -> u64
-    [61; 62) 'i': u32
-    [64; 65) '2': u32
-    [64; 67) '2*i': u32
-    [66; 67) 'i': u32
-    [78; 79) 'b': u64
-    [82; 83) 'a': S
-    [82; 85) 'a.0': fn(u32) -> u64
-    [82; 88) 'a.0(4)': u64
-    [86; 87) '4': u32
-    [94; 95) 'a': S
-    [94; 97) 'a.0': fn(u32) -> u64
-    [94; 100) 'a.0(2)': u64
-    [98; 99) '2': u32
+    44..102 '{     ...0(2) }': u64
+    54..55 'a': S
+    58..59 'S': S(fn(u32) -> u64) -> S
+    58..68 'S(|i| 2*i)': S
+    60..67 '|i| 2*i': |u32| -> u64
+    61..62 'i': u32
+    64..65 '2': u32
+    64..67 '2*i': u32
+    66..67 'i': u32
+    78..79 'b': u64
+    82..83 'a': S
+    82..85 'a.0': fn(u32) -> u64
+    82..88 'a.0(4)': u64
+    86..87 '4': u32
+    94..95 'a': S
+    94..97 'a.0': fn(u32) -> u64
+    94..100 'a.0(2)': u64
+    98..99 '2': u32
     "###
     );
 }
@@ -523,12 +523,12 @@ fn indexing_arrays() {
     assert_snapshot!(
         infer("fn main() { &mut [9][2]; }"),
         @r###"
-    [10; 26) '{ &mut...[2]; }': ()
-    [12; 23) '&mut [9][2]': &mut {unknown}
-    [17; 20) '[9]': [i32; _]
-    [17; 23) '[9][2]': {unknown}
-    [18; 19) '9': i32
-    [21; 22) '2': i32
+    10..26 '{ &mut...[2]; }': ()
+    12..23 '&mut [9][2]': &mut {unknown}
+    17..20 '[9]': [i32; _]
+    17..23 '[9][2]': {unknown}
+    18..19 '9': i32
+    21..22 '2': i32
     "###
     )
 }
@@ -944,34 +944,34 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u32>) {
 }
 "#, true),
         @r###"
-    [30; 34) 'self': &Self
-    [55; 59) 'self': &Self
-    [78; 79) 'x': impl Trait<u16>
-    [98; 100) '{}': ()
-    [155; 156) 'x': impl Trait<u64>
-    [175; 176) 'y': &impl Trait<u32>
-    [196; 324) '{     ...2(); }': ()
-    [202; 203) 'x': impl Trait<u64>
-    [209; 210) 'y': &impl Trait<u32>
-    [220; 221) 'z': S<u16>
-    [224; 225) 'S': S<u16>(u16) -> S<u16>
-    [224; 228) 'S(1)': S<u16>
-    [226; 227) '1': u16
-    [234; 237) 'bar': fn bar(S<u16>)
-    [234; 240) 'bar(z)': ()
-    [238; 239) 'z': S<u16>
-    [246; 247) 'x': impl Trait<u64>
-    [246; 253) 'x.foo()': u64
-    [259; 260) 'y': &impl Trait<u32>
-    [259; 266) 'y.foo()': u32
-    [272; 273) 'z': S<u16>
-    [272; 279) 'z.foo()': u16
-    [285; 286) 'x': impl Trait<u64>
-    [285; 293) 'x.foo2()': i64
-    [299; 300) 'y': &impl Trait<u32>
-    [299; 307) 'y.foo2()': i64
-    [313; 314) 'z': S<u16>
-    [313; 321) 'z.foo2()': i64
+    30..34 'self': &Self
+    55..59 'self': &Self
+    78..79 'x': impl Trait<u16>
+    98..100 '{}': ()
+    155..156 'x': impl Trait<u64>
+    175..176 'y': &impl Trait<u32>
+    196..324 '{     ...2(); }': ()
+    202..203 'x': impl Trait<u64>
+    209..210 'y': &impl Trait<u32>
+    220..221 'z': S<u16>
+    224..225 'S': S<u16>(u16) -> S<u16>
+    224..228 'S(1)': S<u16>
+    226..227 '1': u16
+    234..237 'bar': fn bar(S<u16>)
+    234..240 'bar(z)': ()
+    238..239 'z': S<u16>
+    246..247 'x': impl Trait<u64>
+    246..253 'x.foo()': u64
+    259..260 'y': &impl Trait<u32>
+    259..266 'y.foo()': u32
+    272..273 'z': S<u16>
+    272..279 'z.foo()': u16
+    285..286 'x': impl Trait<u64>
+    285..293 'x.foo2()': i64
+    299..300 'y': &impl Trait<u32>
+    299..307 'y.foo2()': i64
+    313..314 'z': S<u16>
+    313..321 'z.foo2()': i64
     "###
     );
 }
@@ -1005,39 +1005,39 @@ fn test() {
 }
 "#, true),
         @r###"
-    [156; 157) 'x': impl Trait
-    [176; 187) '{ loop {} }': T
-    [178; 185) 'loop {}': !
-    [183; 185) '{}': ()
-    [200; 201) 'x': impl Trait
-    [220; 231) '{ loop {} }': T
-    [222; 229) 'loop {}': !
-    [227; 229) '{}': ()
-    [301; 510) '{     ... i32 }': ()
-    [307; 315) 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
-    [307; 318) 'Foo::bar(S)': {unknown}
-    [316; 317) 'S': S
-    [324; 339) '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    [324; 342) '<F as ...bar(S)': {unknown}
-    [340; 341) 'S': S
-    [348; 354) 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
-    [348; 357) 'F::bar(S)': {unknown}
-    [355; 356) 'S': S
-    [363; 378) 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
-    [363; 381) 'Foo::b...32>(S)': u32
-    [379; 380) 'S': S
-    [387; 409) '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
-    [387; 412) '<F as ...32>(S)': u32
-    [410; 411) 'S': S
-    [419; 422) 'foo': fn foo<{unknown}>(S) -> {unknown}
-    [419; 425) 'foo(S)': {unknown}
-    [423; 424) 'S': S
-    [431; 441) 'foo::<u32>': fn foo<u32>(S) -> u32
-    [431; 444) 'foo::<u32>(S)': u32
-    [442; 443) 'S': S
-    [450; 465) 'foo::<u32, i32>': fn foo<u32>(S) -> u32
-    [450; 468) 'foo::<...32>(S)': u32
-    [466; 467) 'S': S
+    156..157 'x': impl Trait
+    176..187 '{ loop {} }': T
+    178..185 'loop {}': !
+    183..185 '{}': ()
+    200..201 'x': impl Trait
+    220..231 '{ loop {} }': T
+    222..229 'loop {}': !
+    227..229 '{}': ()
+    301..510 '{     ... i32 }': ()
+    307..315 'Foo::bar': fn bar<{unknown}, {unknown}>(S) -> {unknown}
+    307..318 'Foo::bar(S)': {unknown}
+    316..317 'S': S
+    324..339 '<F as Foo>::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    324..342 '<F as ...bar(S)': {unknown}
+    340..341 'S': S
+    348..354 'F::bar': fn bar<F, {unknown}>(S) -> {unknown}
+    348..357 'F::bar(S)': {unknown}
+    355..356 'S': S
+    363..378 'Foo::bar::<u32>': fn bar<{unknown}, u32>(S) -> u32
+    363..381 'Foo::b...32>(S)': u32
+    379..380 'S': S
+    387..409 '<F as ...:<u32>': fn bar<F, u32>(S) -> u32
+    387..412 '<F as ...32>(S)': u32
+    410..411 'S': S
+    419..422 'foo': fn foo<{unknown}>(S) -> {unknown}
+    419..425 'foo(S)': {unknown}
+    423..424 'S': S
+    431..441 'foo::<u32>': fn foo<u32>(S) -> u32
+    431..444 'foo::<u32>(S)': u32
+    442..443 'S': S
+    450..465 'foo::<u32, i32>': fn foo<u32>(S) -> u32
+    450..468 'foo::<...32>(S)': u32
+    466..467 'S': S
     "###
     );
 }
@@ -1062,24 +1062,24 @@ fn test() {
 }
 "#, true),
         @r###"
-    [88; 92) 'self': F<T>
-    [94; 95) 'x': impl Trait
-    [119; 130) '{ loop {} }': (T, U)
-    [121; 128) 'loop {}': !
-    [126; 128) '{}': ()
-    [144; 284) '{     ...ored }': ()
-    [150; 151) 'F': F<{unknown}>
-    [150; 158) 'F.foo(S)': ({unknown}, {unknown})
-    [156; 157) 'S': S
-    [164; 172) 'F::<u32>': F<u32>
-    [164; 179) 'F::<u32>.foo(S)': (u32, {unknown})
-    [177; 178) 'S': S
-    [185; 193) 'F::<u32>': F<u32>
-    [185; 207) 'F::<u3...32>(S)': (u32, i32)
-    [205; 206) 'S': S
-    [213; 221) 'F::<u32>': F<u32>
-    [213; 240) 'F::<u3...32>(S)': (u32, i32)
-    [238; 239) 'S': S
+    88..92 'self': F<T>
+    94..95 'x': impl Trait
+    119..130 '{ loop {} }': (T, U)
+    121..128 'loop {}': !
+    126..128 '{}': ()
+    144..284 '{     ...ored }': ()
+    150..151 'F': F<{unknown}>
+    150..158 'F.foo(S)': ({unknown}, {unknown})
+    156..157 'S': S
+    164..172 'F::<u32>': F<u32>
+    164..179 'F::<u32>.foo(S)': (u32, {unknown})
+    177..178 'S': S
+    185..193 'F::<u32>': F<u32>
+    185..207 'F::<u3...32>(S)': (u32, i32)
+    205..206 'S': S
+    213..221 'F::<u32>': F<u32>
+    213..240 'F::<u3...32>(S)': (u32, i32)
+    238..239 'S': S
     "###
     );
 }
@@ -1098,13 +1098,13 @@ fn test() {
 }
 "#, true),
         @r###"
-    [23; 24) 'x': impl Trait
-    [38; 49) '{ loop {} }': ()
-    [40; 47) 'loop {}': !
-    [45; 47) '{}': ()
-    [91; 124) '{     ...foo; }': ()
-    [101; 102) 'f': fn(S)
-    [118; 121) 'foo': fn foo(S)
+    23..24 'x': impl Trait
+    38..49 '{ loop {} }': ()
+    40..47 'loop {}': !
+    45..47 '{}': ()
+    91..124 '{     ...foo; }': ()
+    101..102 'f': fn(S)
+    118..121 'foo': fn foo(S)
     "###
     );
 }
@@ -1133,29 +1133,29 @@ fn test(x: impl Trait<u64>, y: &impl Trait<u64>) {
 }
 "#),
         @r###"
-    [30; 34) 'self': &Self
-    [55; 59) 'self': &Self
-    [99; 101) '{}': ()
-    [111; 112) 'x': impl Trait<u64>
-    [131; 132) 'y': &impl Trait<u64>
-    [152; 269) '{     ...2(); }': ()
-    [158; 159) 'x': impl Trait<u64>
-    [165; 166) 'y': &impl Trait<u64>
-    [176; 177) 'z': impl Trait<u64>
-    [180; 183) 'bar': fn bar() -> impl Trait<u64>
-    [180; 185) 'bar()': impl Trait<u64>
-    [191; 192) 'x': impl Trait<u64>
-    [191; 198) 'x.foo()': u64
-    [204; 205) 'y': &impl Trait<u64>
-    [204; 211) 'y.foo()': u64
-    [217; 218) 'z': impl Trait<u64>
-    [217; 224) 'z.foo()': u64
-    [230; 231) 'x': impl Trait<u64>
-    [230; 238) 'x.foo2()': i64
-    [244; 245) 'y': &impl Trait<u64>
-    [244; 252) 'y.foo2()': i64
-    [258; 259) 'z': impl Trait<u64>
-    [258; 266) 'z.foo2()': i64
+    30..34 'self': &Self
+    55..59 'self': &Self
+    99..101 '{}': ()
+    111..112 'x': impl Trait<u64>
+    131..132 'y': &impl Trait<u64>
+    152..269 '{     ...2(); }': ()
+    158..159 'x': impl Trait<u64>
+    165..166 'y': &impl Trait<u64>
+    176..177 'z': impl Trait<u64>
+    180..183 'bar': fn bar() -> impl Trait<u64>
+    180..185 'bar()': impl Trait<u64>
+    191..192 'x': impl Trait<u64>
+    191..198 'x.foo()': u64
+    204..205 'y': &impl Trait<u64>
+    204..211 'y.foo()': u64
+    217..218 'z': impl Trait<u64>
+    217..224 'z.foo()': u64
+    230..231 'x': impl Trait<u64>
+    230..238 'x.foo2()': i64
+    244..245 'y': &impl Trait<u64>
+    244..252 'y.foo2()': i64
+    258..259 'z': impl Trait<u64>
+    258..266 'z.foo2()': i64
     "###
     );
 }
@@ -1183,29 +1183,29 @@ fn test(x: dyn Trait<u64>, y: &dyn Trait<u64>) {
 }
 "#),
         @r###"
-    [30; 34) 'self': &Self
-    [55; 59) 'self': &Self
-    [98; 100) '{}': ()
-    [110; 111) 'x': dyn Trait<u64>
-    [129; 130) 'y': &dyn Trait<u64>
-    [149; 266) '{     ...2(); }': ()
-    [155; 156) 'x': dyn Trait<u64>
-    [162; 163) 'y': &dyn Trait<u64>
-    [173; 174) 'z': dyn Trait<u64>
-    [177; 180) 'bar': fn bar() -> dyn Trait<u64>
-    [177; 182) 'bar()': dyn Trait<u64>
-    [188; 189) 'x': dyn Trait<u64>
-    [188; 195) 'x.foo()': u64
-    [201; 202) 'y': &dyn Trait<u64>
-    [201; 208) 'y.foo()': u64
-    [214; 215) 'z': dyn Trait<u64>
-    [214; 221) 'z.foo()': u64
-    [227; 228) 'x': dyn Trait<u64>
-    [227; 235) 'x.foo2()': i64
-    [241; 242) 'y': &dyn Trait<u64>
-    [241; 249) 'y.foo2()': i64
-    [255; 256) 'z': dyn Trait<u64>
-    [255; 263) 'z.foo2()': i64
+    30..34 'self': &Self
+    55..59 'self': &Self
+    98..100 '{}': ()
+    110..111 'x': dyn Trait<u64>
+    129..130 'y': &dyn Trait<u64>
+    149..266 '{     ...2(); }': ()
+    155..156 'x': dyn Trait<u64>
+    162..163 'y': &dyn Trait<u64>
+    173..174 'z': dyn Trait<u64>
+    177..180 'bar': fn bar() -> dyn Trait<u64>
+    177..182 'bar()': dyn Trait<u64>
+    188..189 'x': dyn Trait<u64>
+    188..195 'x.foo()': u64
+    201..202 'y': &dyn Trait<u64>
+    201..208 'y.foo()': u64
+    214..215 'z': dyn Trait<u64>
+    214..221 'z.foo()': u64
+    227..228 'x': dyn Trait<u64>
+    227..235 'x.foo2()': i64
+    241..242 'y': &dyn Trait<u64>
+    241..249 'y.foo2()': i64
+    255..256 'z': dyn Trait<u64>
+    255..263 'z.foo2()': i64
     "###
     );
 }
@@ -1231,17 +1231,17 @@ fn test(s: S<u32, i32>) {
 }
 "#),
         @r###"
-    [33; 37) 'self': &Self
-    [103; 107) 'self': &S<T, U>
-    [129; 140) '{ loop {} }': &dyn Trait<T, U>
-    [131; 138) 'loop {}': !
-    [136; 138) '{}': ()
-    [176; 180) 'self': &Self
-    [252; 253) 's': S<u32, i32>
-    [268; 290) '{     ...z(); }': ()
-    [274; 275) 's': S<u32, i32>
-    [274; 281) 's.bar()': &dyn Trait<u32, i32>
-    [274; 287) 's.bar().baz()': (u32, i32)
+    33..37 'self': &Self
+    103..107 'self': &S<T, U>
+    129..140 '{ loop {} }': &dyn Trait<T, U>
+    131..138 'loop {}': !
+    136..138 '{}': ()
+    176..180 'self': &Self
+    252..253 's': S<u32, i32>
+    268..290 '{     ...z(); }': ()
+    274..275 's': S<u32, i32>
+    274..281 's.bar()': &dyn Trait<u32, i32>
+    274..287 's.bar().baz()': (u32, i32)
     "###
     );
 }
@@ -1265,22 +1265,22 @@ fn test(x: Trait, y: &Trait) -> u64 {
 }
 "#),
         @r###"
-    [27; 31) 'self': &Self
-    [61; 63) '{}': ()
-    [73; 74) 'x': dyn Trait
-    [83; 84) 'y': &dyn Trait
-    [101; 176) '{     ...o(); }': ()
-    [107; 108) 'x': dyn Trait
-    [114; 115) 'y': &dyn Trait
-    [125; 126) 'z': dyn Trait
-    [129; 132) 'bar': fn bar() -> dyn Trait
-    [129; 134) 'bar()': dyn Trait
-    [140; 141) 'x': dyn Trait
-    [140; 147) 'x.foo()': u64
-    [153; 154) 'y': &dyn Trait
-    [153; 160) 'y.foo()': u64
-    [166; 167) 'z': dyn Trait
-    [166; 173) 'z.foo()': u64
+    27..31 'self': &Self
+    61..63 '{}': ()
+    73..74 'x': dyn Trait
+    83..84 'y': &dyn Trait
+    101..176 '{     ...o(); }': ()
+    107..108 'x': dyn Trait
+    114..115 'y': &dyn Trait
+    125..126 'z': dyn Trait
+    129..132 'bar': fn bar() -> dyn Trait
+    129..134 'bar()': dyn Trait
+    140..141 'x': dyn Trait
+    140..147 'x.foo()': u64
+    153..154 'y': &dyn Trait
+    153..160 'y.foo()': u64
+    166..167 'z': dyn Trait
+    166..173 'z.foo()': u64
     "###
     );
 }
@@ -1294,13 +1294,13 @@ fn test(a: impl Trait + 'lifetime, b: impl 'lifetime, c: impl (Trait), d: impl (
 }
 "#),
         @r###"
-    [24; 25) 'a': impl Trait + {error}
-    [51; 52) 'b': impl {error}
-    [70; 71) 'c': impl Trait
-    [87; 88) 'd': impl {error}
-    [108; 109) 'e': impl {error}
-    [124; 125) 'f': impl Trait + {error}
-    [148; 151) '{ }': ()
+    24..25 'a': impl Trait + {error}
+    51..52 'b': impl {error}
+    70..71 'c': impl Trait
+    87..88 'd': impl {error}
+    108..109 'e': impl {error}
+    124..125 'f': impl Trait + {error}
+    148..151 '{ }': ()
     "###
     );
 }
@@ -1349,41 +1349,41 @@ fn test<T: Trait<Type = u32>>(x: T, y: impl Trait<Type = i64>) {
 }
 "#),
         @r###"
-    [50; 51) 't': T
-    [78; 80) '{}': ()
-    [112; 113) 't': T
-    [123; 125) '{}': ()
-    [155; 156) 't': T
-    [166; 169) '{t}': T
-    [167; 168) 't': T
-    [257; 258) 'x': T
-    [263; 264) 'y': impl Trait<Type = i64>
-    [290; 398) '{     ...r>); }': ()
-    [296; 299) 'get': fn get<T>(T) -> <T as Trait>::Type
-    [296; 302) 'get(x)': u32
-    [300; 301) 'x': T
-    [308; 312) 'get2': fn get2<u32, T>(T) -> u32
-    [308; 315) 'get2(x)': u32
-    [313; 314) 'x': T
-    [321; 324) 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
-    [321; 327) 'get(y)': i64
-    [325; 326) 'y': impl Trait<Type = i64>
-    [333; 337) 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
-    [333; 340) 'get2(y)': i64
-    [338; 339) 'y': impl Trait<Type = i64>
-    [346; 349) 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
-    [346; 357) 'get(set(S))': u64
-    [350; 353) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    [350; 356) 'set(S)': S<u64>
-    [354; 355) 'S': S<u64>
-    [363; 367) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    [363; 375) 'get2(set(S))': u64
-    [368; 371) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    [368; 374) 'set(S)': S<u64>
-    [372; 373) 'S': S<u64>
-    [381; 385) 'get2': fn get2<str, S<str>>(S<str>) -> str
-    [381; 395) 'get2(S::<str>)': str
-    [386; 394) 'S::<str>': S<str>
+    50..51 't': T
+    78..80 '{}': ()
+    112..113 't': T
+    123..125 '{}': ()
+    155..156 't': T
+    166..169 '{t}': T
+    167..168 't': T
+    257..258 'x': T
+    263..264 'y': impl Trait<Type = i64>
+    290..398 '{     ...r>); }': ()
+    296..299 'get': fn get<T>(T) -> <T as Trait>::Type
+    296..302 'get(x)': u32
+    300..301 'x': T
+    308..312 'get2': fn get2<u32, T>(T) -> u32
+    308..315 'get2(x)': u32
+    313..314 'x': T
+    321..324 'get': fn get<impl Trait<Type = i64>>(impl Trait<Type = i64>) -> <impl Trait<Type = i64> as Trait>::Type
+    321..327 'get(y)': i64
+    325..326 'y': impl Trait<Type = i64>
+    333..337 'get2': fn get2<i64, impl Trait<Type = i64>>(impl Trait<Type = i64>) -> i64
+    333..340 'get2(y)': i64
+    338..339 'y': impl Trait<Type = i64>
+    346..349 'get': fn get<S<u64>>(S<u64>) -> <S<u64> as Trait>::Type
+    346..357 'get(set(S))': u64
+    350..353 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+    350..356 'set(S)': S<u64>
+    354..355 'S': S<u64>
+    363..367 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+    363..375 'get2(set(S))': u64
+    368..371 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+    368..374 'set(S)': S<u64>
+    372..373 'S': S<u64>
+    381..385 'get2': fn get2<str, S<str>>(S<str>) -> str
+    381..395 'get2(S::<str>)': str
+    386..394 'S::<str>': S<str>
     "###
     );
 }
@@ -1448,11 +1448,11 @@ fn test<T: Trait1<Type = u32>>(x: T) {
 }
 "#),
         @r###"
-    [62; 66) 'self': Self
-    [164; 165) 'x': T
-    [170; 186) '{     ...o(); }': ()
-    [176; 177) 'x': T
-    [176; 183) 'x.foo()': u32
+    62..66 'self': Self
+    164..165 'x': T
+    170..186 '{     ...o(); }': ()
+    176..177 'x': T
+    176..183 'x.foo()': u32
     "###
     );
 }
@@ -1494,15 +1494,15 @@ fn test<T: Trait1, U: Trait2>(x: T, y: U) {
 }
 "#),
         @r###"
-    [50; 54) 'self': &Self
-    [63; 65) '{}': ()
-    [182; 183) 'x': T
-    [188; 189) 'y': U
-    [194; 223) '{     ...o(); }': ()
-    [200; 201) 'x': T
-    [200; 207) 'x.foo()': u32
-    [213; 214) 'y': U
-    [213; 220) 'y.foo()': u32
+    50..54 'self': &Self
+    63..65 '{}': ()
+    182..183 'x': T
+    188..189 'y': U
+    194..223 '{     ...o(); }': ()
+    200..201 'x': T
+    200..207 'x.foo()': u32
+    213..214 'y': U
+    213..220 'y.foo()': u32
     "###
     );
 }
@@ -1523,12 +1523,12 @@ fn test(x: &impl Trait1) {
 }
 "#),
         @r###"
-    [50; 54) 'self': &Self
-    [63; 65) '{}': ()
-    [116; 117) 'x': &impl Trait1
-    [133; 149) '{     ...o(); }': ()
-    [139; 140) 'x': &impl Trait1
-    [139; 146) 'x.foo()': u32
+    50..54 'self': &Self
+    63..65 '{}': ()
+    116..117 'x': &impl Trait1
+    133..149 '{     ...o(); }': ()
+    139..140 'x': &impl Trait1
+    139..146 'x.foo()': u32
     "###
     );
 }
@@ -1546,10 +1546,10 @@ fn test<T: A>(x: T) {
 }
 "#),
         @r###"
-    [44; 45) 'x': T
-    [50; 66) '{     ...o(); }': ()
-    [56; 57) 'x': T
-    [56; 63) 'x.foo()': {unknown}
+    44..45 'x': T
+    50..66 '{     ...o(); }': ()
+    56..57 'x': T
+    56..63 'x.foo()': {unknown}
     "###
     );
 }
@@ -1573,17 +1573,17 @@ fn test() {
 }
 "#),
         @r###"
-    [103; 104) 't': T
-    [114; 116) '{}': ()
-    [146; 147) 't': T
-    [157; 160) '{t}': T
-    [158; 159) 't': T
-    [259; 280) '{     ...S)); }': ()
-    [265; 269) 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
-    [265; 277) 'get2(set(S))': u64
-    [270; 273) 'set': fn set<S<u64>>(S<u64>) -> S<u64>
-    [270; 276) 'set(S)': S<u64>
-    [274; 275) 'S': S<u64>
+    103..104 't': T
+    114..116 '{}': ()
+    146..147 't': T
+    157..160 '{t}': T
+    158..159 't': T
+    259..280 '{     ...S)); }': ()
+    265..269 'get2': fn get2<u64, S<u64>>(S<u64>) -> u64
+    265..277 'get2(set(S))': u64
+    270..273 'set': fn set<S<u64>>(S<u64>) -> S<u64>
+    270..276 'set(S)': S<u64>
+    274..275 'S': S<u64>
     "###
     );
 }
@@ -1603,15 +1603,15 @@ fn test<F: FnOnce(u32, u64) -> u128>(f: F) {
 }
 "#),
         @r###"
-    [57; 61) 'self': Self
-    [63; 67) 'args': Args
-    [150; 151) 'f': F
-    [156; 184) '{     ...2)); }': ()
-    [162; 163) 'f': F
-    [162; 181) 'f.call...1, 2))': u128
-    [174; 180) '(1, 2)': (u32, u64)
-    [175; 176) '1': u32
-    [178; 179) '2': u64
+    57..61 'self': Self
+    63..67 'args': Args
+    150..151 'f': F
+    156..184 '{     ...2)); }': ()
+    162..163 'f': F
+    162..181 'f.call...1, 2))': u128
+    174..180 '(1, 2)': (u32, u64)
+    175..176 '1': u32
+    178..179 '2': u64
     "###
     );
 }
@@ -1638,32 +1638,32 @@ fn test() {
 }
 "#),
         @r###"
-    [148; 152) 'self': Option<T>
-    [154; 155) 'f': F
-    [173; 175) '{}': ()
-    [189; 308) '{     ... 1); }': ()
-    [199; 200) 'x': Option<u32>
-    [203; 215) 'Option::Some': Some<u32>(u32) -> Option<u32>
-    [203; 221) 'Option...(1u32)': Option<u32>
-    [216; 220) '1u32': u32
-    [227; 228) 'x': Option<u32>
-    [227; 243) 'x.map(...v + 1)': Option<u32>
-    [233; 242) '|v| v + 1': |u32| -> u32
-    [234; 235) 'v': u32
-    [237; 238) 'v': u32
-    [237; 242) 'v + 1': u32
-    [241; 242) '1': u32
-    [249; 250) 'x': Option<u32>
-    [249; 265) 'x.map(... 1u64)': Option<u64>
-    [255; 264) '|_v| 1u64': |u32| -> u64
-    [256; 258) '_v': u32
-    [260; 264) '1u64': u64
-    [275; 276) 'y': Option<i64>
-    [292; 293) 'x': Option<u32>
-    [292; 305) 'x.map(|_v| 1)': Option<i64>
-    [298; 304) '|_v| 1': |u32| -> i64
-    [299; 301) '_v': u32
-    [303; 304) '1': i64
+    148..152 'self': Option<T>
+    154..155 'f': F
+    173..175 '{}': ()
+    189..308 '{     ... 1); }': ()
+    199..200 'x': Option<u32>
+    203..215 'Option::Some': Some<u32>(u32) -> Option<u32>
+    203..221 'Option...(1u32)': Option<u32>
+    216..220 '1u32': u32
+    227..228 'x': Option<u32>
+    227..243 'x.map(...v + 1)': Option<u32>
+    233..242 '|v| v + 1': |u32| -> u32
+    234..235 'v': u32
+    237..238 'v': u32
+    237..242 'v + 1': u32
+    241..242 '1': u32
+    249..250 'x': Option<u32>
+    249..265 'x.map(... 1u64)': Option<u64>
+    255..264 '|_v| 1u64': |u32| -> u64
+    256..258 '_v': u32
+    260..264 '1u64': u64
+    275..276 'y': Option<i64>
+    292..293 'x': Option<u32>
+    292..305 'x.map(|_v| 1)': Option<i64>
+    298..304 '|_v| 1': |u32| -> i64
+    299..301 '_v': u32
+    303..304 '1': i64
     "###
     );
 }
@@ -1684,26 +1684,26 @@ fn test<F: FnOnce(u32) -> u64>(f: F) {
 }
 "#),
         @r###"
-    [73; 74) 'f': F
-    [79; 155) '{     ...+ v; }': ()
-    [85; 86) 'f': F
-    [85; 89) 'f(1)': {unknown}
-    [87; 88) '1': i32
-    [99; 100) 'g': |u64| -> i32
-    [103; 112) '|v| v + 1': |u64| -> i32
-    [104; 105) 'v': u64
-    [107; 108) 'v': u64
-    [107; 112) 'v + 1': i32
-    [111; 112) '1': i32
-    [118; 119) 'g': |u64| -> i32
-    [118; 125) 'g(1u64)': i32
-    [120; 124) '1u64': u64
-    [135; 136) 'h': |u128| -> u128
-    [139; 152) '|v| 1u128 + v': |u128| -> u128
-    [140; 141) 'v': u128
-    [143; 148) '1u128': u128
-    [143; 152) '1u128 + v': u128
-    [151; 152) 'v': u128
+    73..74 'f': F
+    79..155 '{     ...+ v; }': ()
+    85..86 'f': F
+    85..89 'f(1)': {unknown}
+    87..88 '1': i32
+    99..100 'g': |u64| -> i32
+    103..112 '|v| v + 1': |u64| -> i32
+    104..105 'v': u64
+    107..108 'v': u64
+    107..112 'v + 1': i32
+    111..112 '1': i32
+    118..119 'g': |u64| -> i32
+    118..125 'g(1u64)': i32
+    120..124 '1u64': u64
+    135..136 'h': |u128| -> u128
+    139..152 '|v| 1u128 + v': |u128| -> u128
+    140..141 'v': u128
+    143..148 '1u128': u128
+    143..152 '1u128 + v': u128
+    151..152 'v': u128
     "###
     );
 }
@@ -1736,54 +1736,54 @@ fn test() {
 }
 "#),
         @r###"
-    [95; 96) 'x': T
-    [101; 102) 'f': F
-    [112; 114) '{}': ()
-    [148; 149) 'f': F
-    [154; 155) 'x': T
-    [165; 167) '{}': ()
-    [202; 206) 'self': S
-    [254; 258) 'self': S
-    [260; 261) 'x': T
-    [266; 267) 'f': F
-    [277; 279) '{}': ()
-    [317; 321) 'self': S
-    [323; 324) 'f': F
-    [329; 330) 'x': T
-    [340; 342) '{}': ()
-    [356; 515) '{     ... S); }': ()
-    [366; 368) 'x1': u64
-    [371; 375) 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
-    [371; 394) 'foo1(S...hod())': u64
-    [376; 377) 'S': S
-    [379; 393) '|s| s.method()': |S| -> u64
-    [380; 381) 's': S
-    [383; 384) 's': S
-    [383; 393) 's.method()': u64
-    [404; 406) 'x2': u64
-    [409; 413) 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
-    [409; 432) 'foo2(|...(), S)': u64
-    [414; 428) '|s| s.method()': |S| -> u64
-    [415; 416) 's': S
-    [418; 419) 's': S
-    [418; 428) 's.method()': u64
-    [430; 431) 'S': S
-    [442; 444) 'x3': u64
-    [447; 448) 'S': S
-    [447; 472) 'S.foo1...hod())': u64
-    [454; 455) 'S': S
-    [457; 471) '|s| s.method()': |S| -> u64
-    [458; 459) 's': S
-    [461; 462) 's': S
-    [461; 471) 's.method()': u64
-    [482; 484) 'x4': u64
-    [487; 488) 'S': S
-    [487; 512) 'S.foo2...(), S)': u64
-    [494; 508) '|s| s.method()': |S| -> u64
-    [495; 496) 's': S
-    [498; 499) 's': S
-    [498; 508) 's.method()': u64
-    [510; 511) 'S': S
+    95..96 'x': T
+    101..102 'f': F
+    112..114 '{}': ()
+    148..149 'f': F
+    154..155 'x': T
+    165..167 '{}': ()
+    202..206 'self': S
+    254..258 'self': S
+    260..261 'x': T
+    266..267 'f': F
+    277..279 '{}': ()
+    317..321 'self': S
+    323..324 'f': F
+    329..330 'x': T
+    340..342 '{}': ()
+    356..515 '{     ... S); }': ()
+    366..368 'x1': u64
+    371..375 'foo1': fn foo1<S, u64, |S| -> u64>(S, |S| -> u64) -> u64
+    371..394 'foo1(S...hod())': u64
+    376..377 'S': S
+    379..393 '|s| s.method()': |S| -> u64
+    380..381 's': S
+    383..384 's': S
+    383..393 's.method()': u64
+    404..406 'x2': u64
+    409..413 'foo2': fn foo2<S, u64, |S| -> u64>(|S| -> u64, S) -> u64
+    409..432 'foo2(|...(), S)': u64
+    414..428 '|s| s.method()': |S| -> u64
+    415..416 's': S
+    418..419 's': S
+    418..428 's.method()': u64
+    430..431 'S': S
+    442..444 'x3': u64
+    447..448 'S': S
+    447..472 'S.foo1...hod())': u64
+    454..455 'S': S
+    457..471 '|s| s.method()': |S| -> u64
+    458..459 's': S
+    461..462 's': S
+    461..471 's.method()': u64
+    482..484 'x4': u64
+    487..488 'S': S
+    487..512 'S.foo2...(), S)': u64
+    494..508 '|s| s.method()': |S| -> u64
+    495..496 's': S
+    498..499 's': S
+    498..508 's.method()': u64
+    510..511 'S': S
     "###
     );
 }
@@ -1858,18 +1858,18 @@ impl Trait for S2 {
 }
 "#,
     ), @r###"
-    [54; 58) 'self': &Self
-    [60; 61) 'x': Trait::Item<Self>
-    [140; 144) 'self': &S
-    [146; 147) 'x': u32
-    [161; 175) '{ let y = x; }': ()
-    [167; 168) 'y': u32
-    [171; 172) 'x': u32
-    [242; 246) 'self': &S2
-    [248; 249) 'x': i32
-    [265; 279) '{ let y = x; }': ()
-    [271; 272) 'y': i32
-    [275; 276) 'x': i32
+    54..58 'self': &Self
+    60..61 'x': Trait::Item<Self>
+    140..144 'self': &S
+    146..147 'x': u32
+    161..175 '{ let y = x; }': ()
+    167..168 'y': u32
+    171..172 'x': u32
+    242..246 'self': &S2
+    248..249 'x': i32
+    265..279 '{ let y = x; }': ()
+    271..272 'y': i32
+    275..276 'x': i32
     "###);
 }
 
@@ -2077,15 +2077,15 @@ impl TokenStream for Rustc {
 }
 "#, true),
         @r###"
-    [1115; 1126) '{ loop {} }': T
-    [1117; 1124) 'loop {}': !
-    [1122; 1124) '{}': ()
-    [1190; 1253) '{     ...     }': {unknown}
-    [1204; 1209) 'group': {unknown}
-    [1225; 1229) 'make': fn make<{unknown}>() -> {unknown}
-    [1225; 1231) 'make()': {unknown}
-    [1241; 1245) 'make': fn make<{unknown}>() -> {unknown}
-    [1241; 1247) 'make()': {unknown}
+    1115..1126 '{ loop {} }': T
+    1117..1124 'loop {}': !
+    1122..1124 '{}': ()
+    1190..1253 '{     ...     }': {unknown}
+    1204..1209 'group': {unknown}
+    1225..1229 'make': fn make<{unknown}>() -> {unknown}
+    1225..1231 'make()': {unknown}
+    1241..1245 'make': fn make<{unknown}>() -> {unknown}
+    1241..1247 'make()': {unknown}
     "###
     );
 }
@@ -2112,37 +2112,37 @@ fn test() -> impl Trait<i32> {
 }
 "#, true),
         @r###"
-    [27; 28) 'x': impl Trait<u32>
-    [47; 58) '{ loop {} }': ()
-    [49; 56) 'loop {}': !
-    [54; 56) '{}': ()
-    [69; 70) 'x': impl Trait<T>
-    [92; 103) '{ loop {} }': T
-    [94; 101) 'loop {}': !
-    [99; 101) '{}': ()
-    [172; 183) '{ loop {} }': T
-    [174; 181) 'loop {}': !
-    [179; 181) '{}': ()
-    [214; 310) '{     ...t()) }': S<{unknown}>
-    [224; 226) 's1': S<u32>
-    [229; 230) 'S': S<u32>(u32) -> S<u32>
-    [229; 241) 'S(default())': S<u32>
-    [231; 238) 'default': fn default<u32>() -> u32
-    [231; 240) 'default()': u32
-    [247; 250) 'foo': fn foo(S<u32>)
-    [247; 254) 'foo(s1)': ()
-    [251; 253) 's1': S<u32>
-    [264; 265) 'x': i32
-    [273; 276) 'bar': fn bar<i32>(S<i32>) -> i32
-    [273; 290) 'bar(S(...lt()))': i32
-    [277; 278) 'S': S<i32>(i32) -> S<i32>
-    [277; 289) 'S(default())': S<i32>
-    [279; 286) 'default': fn default<i32>() -> i32
-    [279; 288) 'default()': i32
-    [296; 297) 'S': S<{unknown}>({unknown}) -> S<{unknown}>
-    [296; 308) 'S(default())': S<{unknown}>
-    [298; 305) 'default': fn default<{unknown}>() -> {unknown}
-    [298; 307) 'default()': {unknown}
+    27..28 'x': impl Trait<u32>
+    47..58 '{ loop {} }': ()
+    49..56 'loop {}': !
+    54..56 '{}': ()
+    69..70 'x': impl Trait<T>
+    92..103 '{ loop {} }': T
+    94..101 'loop {}': !
+    99..101 '{}': ()
+    172..183 '{ loop {} }': T
+    174..181 'loop {}': !
+    179..181 '{}': ()
+    214..310 '{     ...t()) }': S<{unknown}>
+    224..226 's1': S<u32>
+    229..230 'S': S<u32>(u32) -> S<u32>
+    229..241 'S(default())': S<u32>
+    231..238 'default': fn default<u32>() -> u32
+    231..240 'default()': u32
+    247..250 'foo': fn foo(S<u32>)
+    247..254 'foo(s1)': ()
+    251..253 's1': S<u32>
+    264..265 'x': i32
+    273..276 'bar': fn bar<i32>(S<i32>) -> i32
+    273..290 'bar(S(...lt()))': i32
+    277..278 'S': S<i32>(i32) -> S<i32>
+    277..289 'S(default())': S<i32>
+    279..286 'default': fn default<i32>() -> i32
+    279..288 'default()': i32
+    296..297 'S': S<{unknown}>({unknown}) -> S<{unknown}>
+    296..308 'S(default())': S<{unknown}>
+    298..305 'default': fn default<{unknown}>() -> {unknown}
+    298..307 'default()': {unknown}
     "###
     );
 }
@@ -2176,15 +2176,15 @@ fn main() {
 }
 "#),
         @r###"
-    [147; 149) '_v': F
-    [192; 195) '{ }': ()
-    [207; 238) '{     ... }); }': ()
-    [213; 223) 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
-    [213; 235) 'f::<()... z; })': ()
-    [224; 234) '|z| { z; }': |&()| -> ()
-    [225; 226) 'z': &()
-    [228; 234) '{ z; }': ()
-    [230; 231) 'z': &()
+    147..149 '_v': F
+    192..195 '{ }': ()
+    207..238 '{     ... }); }': ()
+    213..223 'f::<(), _>': fn f<(), |&()| -> ()>(|&()| -> ())
+    213..235 'f::<()... z; })': ()
+    224..234 '|z| { z; }': |&()| -> ()
+    225..226 'z': &()
+    228..234 '{ z; }': ()
+    230..231 'z': &()
     "###
     );
 }
@@ -2337,46 +2337,46 @@ fn main() {
 }
 "#),
         @r###"
-    [240; 244) 'self': Self
-    [246; 247) 'f': F
-    [331; 342) '{ loop {} }': FilterMap<Self, F>
-    [333; 340) 'loop {}': !
-    [338; 340) '{}': ()
-    [363; 367) 'self': Self
-    [369; 370) 'f': F
-    [419; 430) '{ loop {} }': ()
-    [421; 428) 'loop {}': !
-    [426; 428) '{}': ()
-    [539; 543) 'self': Self
-    [868; 872) 'self': I
-    [879; 899) '{     ...     }': I
-    [889; 893) 'self': I
-    [958; 969) '{ loop {} }': Vec<T>
-    [960; 967) 'loop {}': !
-    [965; 967) '{}': ()
-    [1156; 1287) '{     ... }); }': ()
-    [1162; 1177) 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
-    [1162; 1179) 'Vec::<...:new()': Vec<i32>
-    [1162; 1191) 'Vec::<...iter()': IntoIter<i32>
-    [1162; 1256) 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
-    [1162; 1284) 'Vec::<... y; })': ()
-    [1210; 1255) '|x| if...None }': |i32| -> Option<u32>
-    [1211; 1212) 'x': i32
-    [1214; 1255) 'if x >...None }': Option<u32>
-    [1217; 1218) 'x': i32
-    [1217; 1222) 'x > 0': bool
-    [1221; 1222) '0': i32
-    [1223; 1241) '{ Some...u32) }': Option<u32>
-    [1225; 1229) 'Some': Some<u32>(u32) -> Option<u32>
-    [1225; 1239) 'Some(x as u32)': Option<u32>
-    [1230; 1231) 'x': i32
-    [1230; 1238) 'x as u32': u32
-    [1247; 1255) '{ None }': Option<u32>
-    [1249; 1253) 'None': Option<u32>
-    [1273; 1283) '|y| { y; }': |u32| -> ()
-    [1274; 1275) 'y': u32
-    [1277; 1283) '{ y; }': ()
-    [1279; 1280) 'y': u32
+    240..244 'self': Self
+    246..247 'f': F
+    331..342 '{ loop {} }': FilterMap<Self, F>
+    333..340 'loop {}': !
+    338..340 '{}': ()
+    363..367 'self': Self
+    369..370 'f': F
+    419..430 '{ loop {} }': ()
+    421..428 'loop {}': !
+    426..428 '{}': ()
+    539..543 'self': Self
+    868..872 'self': I
+    879..899 '{     ...     }': I
+    889..893 'self': I
+    958..969 '{ loop {} }': Vec<T>
+    960..967 'loop {}': !
+    965..967 '{}': ()
+    1156..1287 '{     ... }); }': ()
+    1162..1177 'Vec::<i32>::new': fn new<i32>() -> Vec<i32>
+    1162..1179 'Vec::<...:new()': Vec<i32>
+    1162..1191 'Vec::<...iter()': IntoIter<i32>
+    1162..1256 'Vec::<...one })': FilterMap<IntoIter<i32>, |i32| -> Option<u32>>
+    1162..1284 'Vec::<... y; })': ()
+    1210..1255 '|x| if...None }': |i32| -> Option<u32>
+    1211..1212 'x': i32
+    1214..1255 'if x >...None }': Option<u32>
+    1217..1218 'x': i32
+    1217..1222 'x > 0': bool
+    1221..1222 '0': i32
+    1223..1241 '{ Some...u32) }': Option<u32>
+    1225..1229 'Some': Some<u32>(u32) -> Option<u32>
+    1225..1239 'Some(x as u32)': Option<u32>
+    1230..1231 'x': i32
+    1230..1238 'x as u32': u32
+    1247..1255 '{ None }': Option<u32>
+    1249..1253 'None': Option<u32>
+    1273..1283 '|y| { y; }': |u32| -> ()
+    1274..1275 'y': u32
+    1277..1283 '{ y; }': ()
+    1279..1280 'y': u32
     "###
     );
 }
@@ -2428,13 +2428,13 @@ fn test(x: &dyn Foo) {
 }
 "#, true),
         @r###"
-    [22; 23) 'x': &dyn Foo
-    [35; 37) '{}': ()
-    [47; 48) 'x': &dyn Foo
-    [60; 75) '{     foo(x); }': ()
-    [66; 69) 'foo': fn foo(&dyn Foo)
-    [66; 72) 'foo(x)': ()
-    [70; 71) 'x': &dyn Foo
+    22..23 'x': &dyn Foo
+    35..37 '{}': ()
+    47..48 'x': &dyn Foo
+    60..75 '{     foo(x); }': ()
+    66..69 'foo': fn foo(&dyn Foo)
+    66..72 'foo(x)': ()
+    70..71 'x': &dyn Foo
     "###
     );
 }