Use only one code-path for parsing fixtures

This removes leading newlines everywhere, shifting all ranges in tests
by one

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> {
 }
 "#,
     ), @r###"
-    63..93 '{     ...     }': ()
-    73..86 'Self { x: 1 }': S<u32>
-    83..84 '1': u32
+    49..79 '{     ...     }': ()
+    59..72 'Self { x: 1 }': S<u32>
+    69..70 '1': u32
     "###);
 }
 
@@ -85,9 +85,9 @@ fn foo() {
 
 "#,
     ), @r###"
-    64..84 '{     ...1 }; }': ()
-    70..81 'SS { x: 1 }': S<u32>
-    78..79 '1': u32
+    50..70 '{     ...1 }; }': ()
+    56..67 'SS { x: 1 }': S<u32>
+    64..65 '1': u32
     "###);
 }
 
@@ -175,19 +175,19 @@ fn test(a: u32, b: isize, c: !, d: &str) {
     1.0f32;
 }"#),
         @r###"
-    9..10 'a': u32
-    17..18 'b': isize
-    27..28 'c': !
-    33..34 'd': &str
-    42..121 '{     ...f32; }': ()
-    48..49 'a': u32
-    55..56 'b': isize
-    62..63 'c': !
-    69..70 'd': &str
-    76..82 '1usize': usize
-    88..94 '1isize': isize
-    100..106 '"test"': &str
-    112..118 '1.0f32': f32
+    8..9 'a': u32
+    16..17 'b': isize
+    26..27 'c': !
+    32..33 'd': &str
+    41..120 '{     ...f32; }': ()
+    47..48 'a': u32
+    54..55 'b': isize
+    61..62 'c': !
+    68..69 'd': &str
+    75..81 '1usize': usize
+    87..93 '1isize': isize
+    99..105 '"test"': &str
+    111..117 '1.0f32': f32
     "###
     );
 }
@@ -206,17 +206,17 @@ fn test() {
 }
 "#),
         @r###"
-    11..118 '{     ...= e; }': ()
-    21..22 'a': isize
-    25..31 '1isize': isize
-    41..42 'b': usize
-    52..53 '1': usize
-    63..64 'c': usize
-    67..68 'b': usize
-    78..79 'd': u32
-    94..95 'e': i32
-    105..106 'f': i32
-    114..115 'e': i32
+    10..117 '{     ...= e; }': ()
+    20..21 'a': isize
+    24..30 '1isize': isize
+    40..41 'b': usize
+    51..52 '1': usize
+    62..63 'c': usize
+    66..67 'b': usize
+    77..78 'd': u32
+    93..94 'e': i32
+    104..105 'f': i32
+    113..114 'e': i32
     "###
     );
 }
@@ -237,15 +237,15 @@ fn test() {
 }
 "#),
         @r###"
-    15..20 '{ 1 }': u32
-    17..18 '1': u32
-    48..53 '{ 1 }': u32
-    50..51 '1': u32
-    67..91 '{     ...c(); }': ()
-    73..74 'a': fn a() -> u32
-    73..76 'a()': u32
-    82..86 'b::c': fn c() -> u32
-    82..88 'b::c()': u32
+    14..19 '{ 1 }': u32
+    16..17 '1': u32
+    47..52 '{ 1 }': u32
+    49..50 '1': u32
+    66..90 '{     ...c(); }': ()
+    72..73 'a': fn a() -> u32
+    72..75 'a()': u32
+    81..85 'b::c': fn c() -> u32
+    81..87 'b::c()': u32
     "###
     );
 }
@@ -266,13 +266,13 @@ fn test() {
 }
 "#),
         @r###"
-    41..46 '{ 1 }': i32
-    43..44 '1': i32
-    60..93 '{     ...o(); }': ()
-    66..72 'S::foo': fn foo() -> i32
-    66..74 'S::foo()': i32
-    80..88 '<S>::foo': fn foo() -> i32
-    80..90 '<S>::foo()': i32
+    40..45 '{ 1 }': i32
+    42..43 '1': i32
+    59..92 '{     ...o(); }': ()
+    65..71 'S::foo': fn foo() -> i32
+    65..73 'S::foo()': i32
+    79..87 '<S>::foo': fn foo() -> i32
+    79..89 '<S>::foo()': i32
     "###
     );
 }
@@ -297,22 +297,22 @@ fn test() {
 }
 "#),
         @r###"
-    72..154 '{     ...a.c; }': ()
-    82..83 'c': C
-    86..87 'C': C(usize) -> C
-    86..90 'C(1)': C
-    88..89 '1': usize
-    96..97 'B': B
-    107..108 'a': A
-    114..133 'A { b:...C(1) }': A
-    121..122 'B': B
-    127..128 'C': C(usize) -> C
-    127..131 'C(1)': C
-    129..130 '1': usize
-    139..140 'a': A
-    139..142 'a.b': B
-    148..149 'a': A
-    148..151 'a.c': C
+    71..153 '{     ...a.c; }': ()
+    81..82 'c': C
+    85..86 'C': C(usize) -> C
+    85..89 'C(1)': C
+    87..88 '1': usize
+    95..96 'B': B
+    106..107 'a': A
+    113..132 'A { b:...C(1) }': A
+    120..121 'B': B
+    126..127 'C': C(usize) -> C
+    126..130 'C(1)': C
+    128..129 '1': usize
+    138..139 'a': A
+    138..141 'a.b': B
+    147..148 'a': A
+    147..150 'a.c': C
     "###
     );
 }
@@ -330,10 +330,10 @@ fn test() {
   E::V2;
 }"#),
         @r###"
-    48..82 '{   E:...:V2; }': ()
-    52..70 'E::V1 ...d: 1 }': E
-    67..68 '1': u32
-    74..79 'E::V2': E
+    47..81 '{   E:...:V2; }': ()
+    51..69 'E::V1 ...d: 1 }': E
+    66..67 '1': u32
+    73..78 'E::V2': E
     "###
     );
 }
@@ -357,29 +357,29 @@ fn test(a: &u32, b: &mut u32, c: *const u32, d: *mut u32) {
 }
 "#),
         @r###"
-    9..10 'a': &u32
-    18..19 'b': &mut u32
-    31..32 'c': *const u32
-    46..47 'd': *mut u32
-    59..150 '{     ... *d; }': ()
-    65..66 'a': &u32
-    72..74 '*a': u32
-    73..74 'a': &u32
-    80..82 '&a': &&u32
-    81..82 'a': &u32
-    88..94 '&mut a': &mut &u32
-    93..94 'a': &u32
-    100..101 'b': &mut u32
-    107..109 '*b': u32
-    108..109 'b': &mut u32
-    115..117 '&b': &&mut u32
-    116..117 'b': &mut u32
-    123..124 'c': *const u32
-    130..132 '*c': u32
-    131..132 'c': *const u32
-    138..139 'd': *mut u32
-    145..147 '*d': u32
-    146..147 'd': *mut u32
+    8..9 'a': &u32
+    17..18 'b': &mut u32
+    30..31 'c': *const u32
+    45..46 'd': *mut u32
+    58..149 '{     ... *d; }': ()
+    64..65 'a': &u32
+    71..73 '*a': u32
+    72..73 'a': &u32
+    79..81 '&a': &&u32
+    80..81 'a': &u32
+    87..93 '&mut a': &mut &u32
+    92..93 'a': &u32
+    99..100 'b': &mut u32
+    106..108 '*b': u32
+    107..108 'b': &mut u32
+    114..116 '&b': &&mut u32
+    115..116 'b': &mut u32
+    122..123 'c': *const u32
+    129..131 '*c': u32
+    130..131 'c': *const u32
+    137..138 'd': *mut u32
+    144..146 '*d': u32
+    145..146 'd': *mut u32
     "###
     );
 }
@@ -394,12 +394,12 @@ fn test(a: i32) {
 }
 "#),
         @r###"
-    9..10 'a': i32
-    17..54 '{     ...t a; }': ()
-    23..33 '&raw mut a': *mut i32
-    32..33 'a': i32
-    39..51 '&raw const a': *const i32
-    50..51 'a': i32
+    8..9 'a': i32
+    16..53 '{     ...t a; }': ()
+    22..32 '&raw mut a': *mut i32
+    31..32 'a': i32
+    38..50 '&raw const a': *const i32
+    49..50 'a': i32
     "###
     );
 }
@@ -429,20 +429,20 @@ fn test() {
 }
 "##),
         @r###"
-    11..221 '{     ...o"#; }': ()
-    17..21 '5i32': i32
-    27..31 '5f32': f32
-    37..41 '5f64': f64
-    47..54 '"hello"': &str
-    60..68 'b"bytes"': &[u8; _]
-    74..77 ''c'': char
-    83..87 'b'b'': u8
-    93..97 '3.14': f64
-    103..107 '5000': i32
-    113..118 'false': bool
-    124..128 'true': bool
-    134..202 'r#"   ...    "#': &str
-    208..218 'br#"yolo"#': &[u8; _]
+    10..220 '{     ...o"#; }': ()
+    16..20 '5i32': i32
+    26..30 '5f32': f32
+    36..40 '5f64': f64
+    46..53 '"hello"': &str
+    59..67 'b"bytes"': &[u8; _]
+    73..76 ''c'': char
+    82..86 'b'b'': u8
+    92..96 '3.14': f64
+    102..106 '5000': i32
+    112..117 'false': bool
+    123..127 'true': bool
+    133..201 'r#"   ...    "#': &str
+    207..217 'br#"yolo"#': &[u8; _]
     "###
     );
 }
@@ -472,47 +472,47 @@ fn test(x: SomeType) {
 }
 "#),
         @r###"
-    27..28 'x': SomeType
-    40..272 '{     ...lo"; }': ()
-    50..51 'b': bool
-    54..59 'false': bool
-    69..70 'c': bool
-    73..75 '!b': bool
-    74..75 'b': bool
-    85..86 'a': i128
-    89..92 '100': i128
-    102..103 'd': i128
-    112..114 '-a': i128
-    113..114 'a': i128
-    124..125 'e': i32
-    128..132 '-100': i32
-    129..132 '100': i32
-    142..143 'f': bool
-    146..153 '!!!true': bool
-    147..153 '!!true': bool
-    148..153 '!true': bool
-    149..153 'true': bool
-    163..164 'g': i32
-    167..170 '!42': i32
-    168..170 '42': i32
-    180..181 'h': u32
-    184..190 '!10u32': u32
-    185..190 '10u32': u32
-    200..201 'j': i128
-    204..206 '!a': i128
-    205..206 'a': i128
-    212..217 '-3.14': f64
-    213..217 '3.14': f64
-    223..225 '!3': i32
-    224..225 '3': i32
-    231..233 '-x': {unknown}
-    232..233 'x': SomeType
-    239..241 '!x': {unknown}
-    240..241 'x': SomeType
-    247..255 '-"hello"': {unknown}
-    248..255 '"hello"': &str
-    261..269 '!"hello"': {unknown}
-    262..269 '"hello"': &str
+    26..27 'x': SomeType
+    39..271 '{     ...lo"; }': ()
+    49..50 'b': bool
+    53..58 'false': bool
+    68..69 'c': bool
+    72..74 '!b': bool
+    73..74 'b': bool
+    84..85 'a': i128
+    88..91 '100': i128
+    101..102 'd': i128
+    111..113 '-a': i128
+    112..113 'a': i128
+    123..124 'e': i32
+    127..131 '-100': i32
+    128..131 '100': i32
+    141..142 'f': bool
+    145..152 '!!!true': bool
+    146..152 '!!true': bool
+    147..152 '!true': bool
+    148..152 'true': bool
+    162..163 'g': i32
+    166..169 '!42': i32
+    167..169 '42': i32
+    179..180 'h': u32
+    183..189 '!10u32': u32
+    184..189 '10u32': u32
+    199..200 'j': i128
+    203..205 '!a': i128
+    204..205 'a': i128
+    211..216 '-3.14': f64
+    212..216 '3.14': f64
+    222..224 '!3': i32
+    223..224 '3': i32
+    230..232 '-x': {unknown}
+    231..232 'x': SomeType
+    238..240 '!x': {unknown}
+    239..240 'x': SomeType
+    246..254 '-"hello"': {unknown}
+    247..254 '"hello"': &str
+    260..268 '!"hello"': {unknown}
+    261..268 '"hello"': &str
     "###
     );
 }
@@ -535,26 +535,26 @@ fn test() -> &mut &f64 {
 }
 "#),
         @r###"
-    14..15 'x': u32
-    22..24 '{}': ()
-    78..231 '{     ...t &c }': &mut &f64
-    88..89 'a': u32
-    92..108 'unknow...nction': {unknown}
-    92..110 'unknow...tion()': u32
-    116..125 'takes_u32': fn takes_u32(u32)
-    116..128 'takes_u32(a)': ()
-    126..127 'a': u32
-    138..139 'b': i32
-    142..158 'unknow...nction': {unknown}
-    142..160 'unknow...tion()': i32
-    166..184 'S { i3...d: b }': S
-    181..182 'b': i32
-    194..195 'c': f64
-    198..214 'unknow...nction': {unknown}
-    198..216 'unknow...tion()': f64
-    222..229 '&mut &c': &mut &f64
-    227..229 '&c': &f64
-    228..229 'c': f64
+    13..14 'x': u32
+    21..23 '{}': ()
+    77..230 '{     ...t &c }': &mut &f64
+    87..88 'a': u32
+    91..107 'unknow...nction': {unknown}
+    91..109 'unknow...tion()': u32
+    115..124 'takes_u32': fn takes_u32(u32)
+    115..127 'takes_u32(a)': ()
+    125..126 'a': u32
+    137..138 'b': i32
+    141..157 'unknow...nction': {unknown}
+    141..159 'unknow...tion()': i32
+    165..183 'S { i3...d: b }': S
+    180..181 'b': i32
+    193..194 'c': f64
+    197..213 'unknow...nction': {unknown}
+    197..215 'unknow...tion()': f64
+    221..228 '&mut &c': &mut &f64
+    226..228 '&c': &f64
+    227..228 'c': f64
     "###
     );
 }
@@ -581,16 +581,16 @@ impl S {
 }
 "#),
         @r###"
-    34..38 'self': &S
-    40..61 '{     ...     }': ()
-    50..54 'self': &S
-    75..79 'self': &S
-    88..109 '{     ...     }': ()
-    98..102 'self': &S
-    133..153 '{     ...     }': S
-    143..147 'S {}': S
-    177..200 '{     ...     }': S
-    187..194 'Self {}': S
+    33..37 'self': &S
+    39..60 '{     ...     }': ()
+    49..53 'self': &S
+    74..78 'self': &S
+    87..108 '{     ...     }': ()
+    97..101 'self': &S
+    132..152 '{     ...     }': S
+    142..146 'S {}': S
+    176..199 '{     ...     }': S
+    186..193 'Self {}': S
     "###
     );
 }
@@ -624,17 +624,17 @@ impl E {
 }
 "#),
         @r###"
-    87..108 '{     ...     }': ()
-    97..101 'Self': S1
-    135..159 '{     ...     }': ()
-    145..149 'Self': S2(isize) -> S2
-    145..152 'Self(1)': S2
-    150..151 '1': isize
-    185..231 '{     ...     }': ()
-    195..203 'Self::V1': E
-    213..221 'Self::V2': V2(u32) -> E
-    213..224 'Self::V2(1)': E
-    222..223 '1': u32
+    86..107 '{     ...     }': ()
+    96..100 'Self': S1
+    134..158 '{     ...     }': ()
+    144..148 'Self': S2(isize) -> S2
+    144..151 'Self(1)': S2
+    149..150 '1': isize
+    184..230 '{     ...     }': ()
+    194..202 'Self::V1': E
+    212..220 'Self::V2': V2(u32) -> E
+    212..223 'Self::V2(1)': E
+    221..222 '1': u32
     "###
     );
 }
@@ -664,56 +664,56 @@ fn test() -> bool {
 }
 "#),
         @r###"
-    6..7 'x': bool
-    22..34 '{     0i32 }': i32
-    28..32 '0i32': i32
-    54..370 '{     ... < 3 }': bool
-    64..65 'x': bool
-    68..69 'a': bool
-    68..74 'a && b': bool
-    73..74 'b': bool
-    84..85 'y': bool
-    88..92 'true': bool
-    88..101 'true || false': bool
-    96..101 'false': bool
-    111..112 'z': bool
-    115..116 'x': bool
-    115..121 'x == y': bool
-    120..121 'y': bool
-    131..132 't': bool
-    135..136 'x': bool
-    135..141 'x != y': bool
-    140..141 'y': bool
-    151..162 'minus_forty': isize
-    172..180 '-40isize': isize
-    173..180 '40isize': isize
-    190..191 'h': bool
-    194..205 'minus_forty': isize
-    194..216 'minus_...ONST_2': bool
-    209..216 'CONST_2': isize
-    226..227 'c': i32
-    230..231 'f': fn f(bool) -> i32
-    230..239 'f(z || y)': i32
-    230..243 'f(z || y) + 5': i32
-    232..233 'z': bool
-    232..238 'z || y': bool
-    237..238 'y': bool
-    242..243 '5': i32
-    253..254 'd': {unknown}
-    257..258 'b': {unknown}
-    268..269 'g': ()
-    272..283 'minus_forty': isize
-    272..288 'minus_...y ^= i': ()
-    287..288 'i': isize
-    298..301 'ten': usize
-    311..313 '10': usize
-    323..336 'ten_is_eleven': bool
-    339..342 'ten': usize
-    339..354 'ten == some_num': bool
-    346..354 'some_num': usize
-    361..364 'ten': usize
-    361..368 'ten < 3': bool
-    367..368 '3': usize
+    5..6 'x': bool
+    21..33 '{     0i32 }': i32
+    27..31 '0i32': i32
+    53..369 '{     ... < 3 }': bool
+    63..64 'x': bool
+    67..68 'a': bool
+    67..73 'a && b': bool
+    72..73 'b': bool
+    83..84 'y': bool
+    87..91 'true': bool
+    87..100 'true || false': bool
+    95..100 'false': bool
+    110..111 'z': bool
+    114..115 'x': bool
+    114..120 'x == y': bool
+    119..120 'y': bool
+    130..131 't': bool
+    134..135 'x': bool
+    134..140 'x != y': bool
+    139..140 'y': bool
+    150..161 'minus_forty': isize
+    171..179 '-40isize': isize
+    172..179 '40isize': isize
+    189..190 'h': bool
+    193..204 'minus_forty': isize
+    193..215 'minus_...ONST_2': bool
+    208..215 'CONST_2': isize
+    225..226 'c': i32
+    229..230 'f': fn f(bool) -> i32
+    229..238 'f(z || y)': i32
+    229..242 'f(z || y) + 5': i32
+    231..232 'z': bool
+    231..237 'z || y': bool
+    236..237 'y': bool
+    241..242 '5': i32
+    252..253 'd': {unknown}
+    256..257 'b': {unknown}
+    267..268 'g': ()
+    271..282 'minus_forty': isize
+    271..287 'minus_...y ^= i': ()
+    286..287 'i': isize
+    297..300 'ten': usize
+    310..312 '10': usize
+    322..335 'ten_is_eleven': bool
+    338..341 'ten': usize
+    338..353 'ten == some_num': bool
+    345..353 'some_num': usize
+    360..363 'ten': usize
+    360..367 'ten < 3': bool
+    366..367 '3': usize
     "###
     );
 }
@@ -728,13 +728,13 @@ fn test() {
 }
 "#),
         @r###"
-    11..48 '{     ...5u8; }': ()
-    17..21 '1u32': u32
-    17..28 '1u32 << 5u8': u32
-    25..28 '5u8': u8
-    34..38 '1u32': u32
-    34..45 '1u32 >> 5u8': u32
-    42..45 '5u8': u8
+    10..47 '{     ...5u8; }': ()
+    16..20 '1u32': u32
+    16..27 '1u32 << 5u8': u32
+    24..27 '5u8': u8
+    33..37 '1u32': u32
+    33..44 '1u32 >> 5u8': u32
+    41..44 '5u8': u8
     "###
     );
 }
@@ -767,49 +767,49 @@ fn test2(a1: *const A, a2: *mut A) {
 }
 "#),
         @r###"
-    44..45 'a': A
-    50..213 '{     ...5.b; }': ()
-    60..62 'a1': A
-    65..66 'a': A
-    72..74 'a1': A
-    72..76 'a1.b': B
-    86..88 'a2': &A
-    91..93 '&a': &A
-    92..93 'a': A
-    99..101 'a2': &A
-    99..103 'a2.b': B
-    113..115 'a3': &mut A
-    118..124 '&mut a': &mut A
-    123..124 'a': A
-    130..132 'a3': &mut A
-    130..134 'a3.b': B
-    144..146 'a4': &&&&&&&A
-    149..157 '&&&&&&&a': &&&&&&&A
-    150..157 '&&&&&&a': &&&&&&A
-    151..157 '&&&&&a': &&&&&A
-    152..157 '&&&&a': &&&&A
-    153..157 '&&&a': &&&A
-    154..157 '&&a': &&A
-    155..157 '&a': &A
-    156..157 'a': A
-    163..165 'a4': &&&&&&&A
-    163..167 'a4.b': B
-    177..179 'a5': &mut &&mut &&mut A
-    182..200 '&mut &...&mut a': &mut &&mut &&mut A
-    187..200 '&&mut &&mut a': &&mut &&mut A
-    188..200 '&mut &&mut a': &mut &&mut A
-    193..200 '&&mut a': &&mut A
-    194..200 '&mut a': &mut A
-    199..200 'a': A
-    206..208 'a5': &mut &&mut &&mut A
-    206..210 'a5.b': B
-    224..226 'a1': *const A
-    238..240 'a2': *mut A
-    250..273 '{     ...2.b; }': ()
-    256..258 'a1': *const A
-    256..260 'a1.b': B
-    266..268 'a2': *mut A
-    266..270 'a2.b': B
+    43..44 'a': A
+    49..212 '{     ...5.b; }': ()
+    59..61 'a1': A
+    64..65 'a': A
+    71..73 'a1': A
+    71..75 'a1.b': B
+    85..87 'a2': &A
+    90..92 '&a': &A
+    91..92 'a': A
+    98..100 'a2': &A
+    98..102 'a2.b': B
+    112..114 'a3': &mut A
+    117..123 '&mut a': &mut A
+    122..123 'a': A
+    129..131 'a3': &mut A
+    129..133 'a3.b': B
+    143..145 'a4': &&&&&&&A
+    148..156 '&&&&&&&a': &&&&&&&A
+    149..156 '&&&&&&a': &&&&&&A
+    150..156 '&&&&&a': &&&&&A
+    151..156 '&&&&a': &&&&A
+    152..156 '&&&a': &&&A
+    153..156 '&&a': &&A
+    154..156 '&a': &A
+    155..156 'a': A
+    162..164 'a4': &&&&&&&A
+    162..166 'a4.b': B
+    176..178 'a5': &mut &&mut &&mut A
+    181..199 '&mut &...&mut a': &mut &&mut &&mut A
+    186..199 '&&mut &&mut a': &&mut &&mut A
+    187..199 '&mut &&mut a': &mut &&mut A
+    192..199 '&&mut a': &&mut A
+    193..199 '&mut a': &mut A
+    198..199 'a': A
+    205..207 'a5': &mut &&mut &&mut A
+    205..209 'a5.b': B
+    223..225 'a1': *const A
+    237..239 'a2': *mut A
+    249..272 '{     ...2.b; }': ()
+    255..257 'a1': *const A
+    255..259 'a1.b': B
+    265..267 'a2': *mut A
+    265..269 'a2.b': B
     "###
     );
 }
@@ -846,30 +846,30 @@ fn test() {
 }
 "#),
         @r###"
-    68..72 'self': &Self
-    139..143 'self': &A<T>
-    151..174 '{     ...     }': &T
-    161..168 '&self.0': &T
-    162..166 'self': &A<T>
-    162..168 'self.0': T
-    255..259 'self': &B<T>
-    278..301 '{     ...     }': &T
-    288..295 '&self.0': &T
-    289..293 'self': &B<T>
-    289..295 'self.0': T
-    315..353 '{     ...))); }': ()
-    325..326 't': &i32
-    329..335 'A::foo': fn foo<i32>(&A<i32>) -> &i32
-    329..350 'A::foo...42))))': &i32
-    336..349 '&&B(B(A(42)))': &&B<B<A<i32>>>
-    337..349 '&B(B(A(42)))': &B<B<A<i32>>>
-    338..339 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-    338..349 'B(B(A(42)))': B<B<A<i32>>>
-    340..341 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-    340..348 'B(A(42))': B<A<i32>>
-    342..343 'A': A<i32>(i32) -> A<i32>
-    342..347 'A(42)': A<i32>
-    344..346 '42': i32
+    67..71 'self': &Self
+    138..142 'self': &A<T>
+    150..173 '{     ...     }': &T
+    160..167 '&self.0': &T
+    161..165 'self': &A<T>
+    161..167 'self.0': T
+    254..258 'self': &B<T>
+    277..300 '{     ...     }': &T
+    287..294 '&self.0': &T
+    288..292 'self': &B<T>
+    288..294 'self.0': T
+    314..352 '{     ...))); }': ()
+    324..325 't': &i32
+    328..334 'A::foo': fn foo<i32>(&A<i32>) -> &i32
+    328..349 'A::foo...42))))': &i32
+    335..348 '&&B(B(A(42)))': &&B<B<A<i32>>>
+    336..348 '&B(B(A(42)))': &B<B<A<i32>>>
+    337..338 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+    337..348 'B(B(A(42)))': B<B<A<i32>>>
+    339..340 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+    339..347 'B(A(42))': B<A<i32>>
+    341..342 'A': A<i32>(i32) -> A<i32>
+    341..346 'A(42)': A<i32>
+    343..345 '42': i32
     "###
     );
 }
@@ -906,34 +906,34 @@ fn test(a: A<i32>) {
 }
 "#),
         @r###"
-    68..72 'self': &Self
-    144..148 'self': &A<T>
-    150..151 'x': &A<T>
-    166..187 '{     ...     }': &T
-    176..181 '&*x.0': &T
-    177..181 '*x.0': T
-    178..179 'x': &A<T>
-    178..181 'x.0': *mut T
-    268..272 'self': &B<T>
-    291..314 '{     ...     }': &T
-    301..308 '&self.0': &T
-    302..306 'self': &B<T>
-    302..308 'self.0': T
-    326..327 'a': A<i32>
-    337..383 '{     ...))); }': ()
-    347..348 't': &i32
-    351..352 'A': A<i32>(*mut i32) -> A<i32>
-    351..365 'A(0 as *mut _)': A<i32>
-    351..380 'A(0 as...B(a)))': &i32
-    353..354 '0': i32
-    353..364 '0 as *mut _': *mut i32
-    370..379 '&&B(B(a))': &&B<B<A<i32>>>
-    371..379 '&B(B(a))': &B<B<A<i32>>>
-    372..373 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
-    372..379 'B(B(a))': B<B<A<i32>>>
-    374..375 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
-    374..378 'B(a)': B<A<i32>>
-    376..377 'a': A<i32>
+    67..71 'self': &Self
+    143..147 'self': &A<T>
+    149..150 'x': &A<T>
+    165..186 '{     ...     }': &T
+    175..180 '&*x.0': &T
+    176..180 '*x.0': T
+    177..178 'x': &A<T>
+    177..180 'x.0': *mut T
+    267..271 'self': &B<T>
+    290..313 '{     ...     }': &T
+    300..307 '&self.0': &T
+    301..305 'self': &B<T>
+    301..307 'self.0': T
+    325..326 'a': A<i32>
+    336..382 '{     ...))); }': ()
+    346..347 't': &i32
+    350..351 'A': A<i32>(*mut i32) -> A<i32>
+    350..364 'A(0 as *mut _)': A<i32>
+    350..379 'A(0 as...B(a)))': &i32
+    352..353 '0': i32
+    352..363 '0 as *mut _': *mut i32
+    369..378 '&&B(B(a))': &&B<B<A<i32>>>
+    370..378 '&B(B(a))': &B<B<A<i32>>>
+    371..372 'B': B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>
+    371..378 'B(B(a))': B<B<A<i32>>>
+    373..374 'B': B<A<i32>>(A<i32>) -> B<A<i32>>
+    373..377 'B(a)': B<A<i32>>
+    375..376 'a': A<i32>
     "###
     );
 }
@@ -952,16 +952,16 @@ fn main(foo: Foo) {
 }
 "#),
         @r###"
-    35..38 'foo': Foo
-    45..109 '{     ...   } }': ()
-    51..107 'if tru...     }': ()
-    54..58 'true': bool
-    59..67 '{      }': ()
-    73..107 'if fal...     }': i32
-    76..81 'false': bool
-    82..107 '{     ...     }': i32
-    92..95 'foo': Foo
-    92..101 'foo.field': i32
+    34..37 'foo': Foo
+    44..108 '{     ...   } }': ()
+    50..106 'if tru...     }': ()
+    53..57 'true': bool
+    58..66 '{      }': ()
+    72..106 'if fal...     }': i32
+    75..80 'false': bool
+    81..106 '{     ...     }': i32
+    91..94 'foo': Foo
+    91..100 'foo.field': i32
     "###
     )
 }
@@ -993,38 +993,38 @@ fn foo() {
     };
 }"#),
         @r###"
-    10..323 '{     ...  }; }': ()
-    20..23 '_x1': i32
-    26..80 'if tru...     }': i32
-    29..33 'true': bool
-    34..51 '{     ...     }': i32
-    44..45 '1': i32
-    57..80 '{     ...     }': i32
-    67..73 'return': !
-    90..93 '_x2': i32
-    96..149 'if tru...     }': i32
-    99..103 'true': bool
-    104..121 '{     ...     }': i32
-    114..115 '2': i32
-    127..149 '{     ...     }': !
-    137..143 'return': !
-    159..162 '_x3': i32
-    165..247 'match ...     }': i32
-    171..175 'true': bool
-    186..190 'true': bool
-    186..190 'true': bool
-    194..195 '3': i32
-    205..206 '_': bool
-    210..241 '{     ...     }': i32
-    224..230 'return': !
-    257..260 '_x4': i32
-    263..320 'match ...     }': i32
-    269..273 'true': bool
-    284..288 'true': bool
-    284..288 'true': bool
-    292..293 '4': i32
-    303..304 '_': bool
-    308..314 'return': !
+    9..322 '{     ...  }; }': ()
+    19..22 '_x1': i32
+    25..79 'if tru...     }': i32
+    28..32 'true': bool
+    33..50 '{     ...     }': i32
+    43..44 '1': i32
+    56..79 '{     ...     }': i32
+    66..72 'return': !
+    89..92 '_x2': i32
+    95..148 'if tru...     }': i32
+    98..102 'true': bool
+    103..120 '{     ...     }': i32
+    113..114 '2': i32
+    126..148 '{     ...     }': !
+    136..142 'return': !
+    158..161 '_x3': i32
+    164..246 'match ...     }': i32
+    170..174 'true': bool
+    185..189 'true': bool
+    185..189 'true': bool
+    193..194 '3': i32
+    204..205 '_': bool
+    209..240 '{     ...     }': i32
+    223..229 'return': !
+    256..259 '_x4': i32
+    262..319 'match ...     }': i32
+    268..272 'true': bool
+    283..287 'true': bool
+    283..287 'true': bool
+    291..292 '4': i32
+    302..303 '_': bool
+    307..313 'return': !
     "###
     )
 }
@@ -1052,24 +1052,24 @@ fn test(a: A) {
 }
 "#),
         @r###"
-    32..36 'self': A
-    38..39 'x': u32
-    53..55 '{}': ()
-    103..107 'self': &A
-    109..110 'x': u64
-    124..126 '{}': ()
-    144..145 'a': A
-    150..198 '{     ...(1); }': ()
-    156..157 'a': A
-    156..164 'a.foo(1)': i32
-    162..163 '1': u32
-    170..181 '(&a).bar(1)': i64
-    171..173 '&a': &A
-    172..173 'a': A
-    179..180 '1': u64
-    187..188 'a': A
-    187..195 'a.bar(1)': i64
-    193..194 '1': u64
+    31..35 'self': A
+    37..38 'x': u32
+    52..54 '{}': ()
+    102..106 'self': &A
+    108..109 'x': u64
+    123..125 '{}': ()
+    143..144 'a': A
+    149..197 '{     ...(1); }': ()
+    155..156 'a': A
+    155..163 'a.foo(1)': i32
+    161..162 '1': u32
+    169..180 '(&a).bar(1)': i64
+    170..172 '&a': &A
+    171..172 'a': A
+    178..179 '1': u64
+    186..187 'a': A
+    186..194 'a.bar(1)': i64
+    192..193 '1': u64
     "###
     );
 }
@@ -1088,11 +1088,11 @@ fn test() {
 }
 "#),
         @r###"
-    40..44 'self': &str
-    53..55 '{}': ()
-    69..89 '{     ...o(); }': ()
-    75..80 '"foo"': &str
-    75..86 '"foo".foo()': i32
+    39..43 'self': &str
+    52..54 '{}': ()
+    68..88 '{     ...o(); }': ()
+    74..79 '"foo"': &str
+    74..85 '"foo".foo()': i32
     "###
     );
 }
@@ -1111,33 +1111,33 @@ fn test(x: &str, y: isize) {
 }
 "#),
         @r###"
-    9..10 'x': &str
-    18..19 'y': isize
-    28..170 '{     ...d"); }': ()
-    38..39 'a': (u32, &str)
-    55..63 '(1, "a")': (u32, &str)
-    56..57 '1': u32
-    59..62 '"a"': &str
-    73..74 'b': ((u32, &str), &str)
-    77..83 '(a, x)': ((u32, &str), &str)
-    78..79 'a': (u32, &str)
-    81..82 'x': &str
-    93..94 'c': (isize, &str)
-    97..103 '(y, x)': (isize, &str)
-    98..99 'y': isize
-    101..102 'x': &str
-    113..114 'd': ((isize, &str), &str)
-    117..123 '(c, x)': ((isize, &str), &str)
-    118..119 'c': (isize, &str)
-    121..122 'x': &str
-    133..134 'e': (i32, &str)
-    137..145 '(1, "e")': (i32, &str)
-    138..139 '1': i32
-    141..144 '"e"': &str
-    155..156 'f': ((i32, &str), &str)
-    159..167 '(e, "d")': ((i32, &str), &str)
-    160..161 'e': (i32, &str)
-    163..166 '"d"': &str
+    8..9 'x': &str
+    17..18 'y': isize
+    27..169 '{     ...d"); }': ()
+    37..38 'a': (u32, &str)
+    54..62 '(1, "a")': (u32, &str)
+    55..56 '1': u32
+    58..61 '"a"': &str
+    72..73 'b': ((u32, &str), &str)
+    76..82 '(a, x)': ((u32, &str), &str)
+    77..78 'a': (u32, &str)
+    80..81 'x': &str
+    92..93 'c': (isize, &str)
+    96..102 '(y, x)': (isize, &str)
+    97..98 'y': isize
+    100..101 'x': &str
+    112..113 'd': ((isize, &str), &str)
+    116..122 '(c, x)': ((isize, &str), &str)
+    117..118 'c': (isize, &str)
+    120..121 'x': &str
+    132..133 'e': (i32, &str)
+    136..144 '(1, "e")': (i32, &str)
+    137..138 '1': i32
+    140..143 '"e"': &str
+    154..155 'f': ((i32, &str), &str)
+    158..166 '(e, "d")': ((i32, &str), &str)
+    159..160 'e': (i32, &str)
+    162..165 '"d"': &str
     "###
     );
 }
@@ -1165,58 +1165,58 @@ fn test(x: &str, y: isize) {
 }
 "#),
         @r###"
-    9..10 'x': &str
-    18..19 'y': isize
-    28..293 '{     ... []; }': ()
-    38..39 'a': [&str; _]
-    42..45 '[x]': [&str; _]
-    43..44 'x': &str
-    55..56 'b': [[&str; _]; _]
-    59..65 '[a, a]': [[&str; _]; _]
-    60..61 'a': [&str; _]
-    63..64 'a': [&str; _]
-    75..76 'c': [[[&str; _]; _]; _]
-    79..85 '[b, b]': [[[&str; _]; _]; _]
-    80..81 'b': [[&str; _]; _]
-    83..84 'b': [[&str; _]; _]
-    96..97 'd': [isize; _]
-    100..112 '[y, 1, 2, 3]': [isize; _]
-    101..102 'y': isize
-    104..105 '1': isize
-    107..108 '2': isize
-    110..111 '3': isize
-    122..123 'd': [isize; _]
-    126..138 '[1, y, 2, 3]': [isize; _]
-    127..128 '1': isize
-    130..131 'y': isize
-    133..134 '2': isize
-    136..137 '3': isize
-    148..149 'e': [isize; _]
-    152..155 '[y]': [isize; _]
-    153..154 'y': isize
-    165..166 'f': [[isize; _]; _]
-    169..175 '[d, d]': [[isize; _]; _]
-    170..171 'd': [isize; _]
-    173..174 'd': [isize; _]
-    185..186 'g': [[isize; _]; _]
-    189..195 '[e, e]': [[isize; _]; _]
-    190..191 'e': [isize; _]
-    193..194 'e': [isize; _]
-    206..207 'h': [i32; _]
-    210..216 '[1, 2]': [i32; _]
-    211..212 '1': i32
-    214..215 '2': i32
-    226..227 'i': [&str; _]
-    230..240 '["a", "b"]': [&str; _]
-    231..234 '"a"': &str
-    236..239 '"b"': &str
-    251..252 'b': [[&str; _]; _]
-    255..265 '[a, ["b"]]': [[&str; _]; _]
-    256..257 'a': [&str; _]
-    259..264 '["b"]': [&str; _]
-    260..263 '"b"': &str
-    275..276 'x': [u8; _]
-    288..290 '[]': [u8; _]
+    8..9 'x': &str
+    17..18 'y': isize
+    27..292 '{     ... []; }': ()
+    37..38 'a': [&str; _]
+    41..44 '[x]': [&str; _]
+    42..43 'x': &str
+    54..55 'b': [[&str; _]; _]
+    58..64 '[a, a]': [[&str; _]; _]
+    59..60 'a': [&str; _]
+    62..63 'a': [&str; _]
+    74..75 'c': [[[&str; _]; _]; _]
+    78..84 '[b, b]': [[[&str; _]; _]; _]
+    79..80 'b': [[&str; _]; _]
+    82..83 'b': [[&str; _]; _]
+    95..96 'd': [isize; _]
+    99..111 '[y, 1, 2, 3]': [isize; _]
+    100..101 'y': isize
+    103..104 '1': isize
+    106..107 '2': isize
+    109..110 '3': isize
+    121..122 'd': [isize; _]
+    125..137 '[1, y, 2, 3]': [isize; _]
+    126..127 '1': isize
+    129..130 'y': isize
+    132..133 '2': isize
+    135..136 '3': isize
+    147..148 'e': [isize; _]
+    151..154 '[y]': [isize; _]
+    152..153 'y': isize
+    164..165 'f': [[isize; _]; _]
+    168..174 '[d, d]': [[isize; _]; _]
+    169..170 'd': [isize; _]
+    172..173 'd': [isize; _]
+    184..185 'g': [[isize; _]; _]
+    188..194 '[e, e]': [[isize; _]; _]
+    189..190 'e': [isize; _]
+    192..193 'e': [isize; _]
+    205..206 'h': [i32; _]
+    209..215 '[1, 2]': [i32; _]
+    210..211 '1': i32
+    213..214 '2': i32
+    225..226 'i': [&str; _]
+    229..239 '["a", "b"]': [&str; _]
+    230..233 '"a"': &str
+    235..238 '"b"': &str
+    250..251 'b': [[&str; _]; _]
+    254..264 '[a, ["b"]]': [[&str; _]; _]
+    255..256 'a': [&str; _]
+    258..263 '["b"]': [&str; _]
+    259..262 '"b"': &str
+    274..275 'x': [u8; _]
+    287..289 '[]': [u8; _]
     "###
     );
 }
@@ -1238,21 +1238,21 @@ fn test(a1: A<u32>, i: i32) {
 }
 "#),
         @r###"
-    36..38 'a1': A<u32>
-    48..49 'i': i32
-    56..147 '{     ...3.x; }': ()
-    62..64 'a1': A<u32>
-    62..66 'a1.x': u32
-    76..78 'a2': A<i32>
-    81..91 'A { x: i }': A<i32>
-    88..89 'i': i32
-    97..99 'a2': A<i32>
-    97..101 'a2.x': i32
-    111..113 'a3': A<i128>
-    116..134 'A::<i1...x: 1 }': A<i128>
-    131..132 '1': i128
-    140..142 'a3': A<i128>
-    140..144 'a3.x': i128
+    35..37 'a1': A<u32>
+    47..48 'i': i32
+    55..146 '{     ...3.x; }': ()
+    61..63 'a1': A<u32>
+    61..65 'a1.x': u32
+    75..77 'a2': A<i32>
+    80..90 'A { x: i }': A<i32>
+    87..88 'i': i32
+    96..98 'a2': A<i32>
+    96..100 'a2.x': i32
+    110..112 'a3': A<i128>
+    115..133 'A::<i1...x: 1 }': A<i128>
+    130..131 '1': i128
+    139..141 'a3': A<i128>
+    139..143 'a3.x': i128
     "###
     );
 }
@@ -1275,22 +1275,22 @@ fn test() {
 }
 "#),
         @r###"
-    76..184 '{     ...one; }': ()
-    82..83 'A': A<i32>(i32) -> A<i32>
-    82..87 'A(42)': A<i32>
-    84..86 '42': i32
-    93..94 'A': A<u128>(u128) -> A<u128>
-    93..102 'A(42u128)': A<u128>
-    95..101 '42u128': u128
-    108..112 'Some': Some<&str>(&str) -> Option<&str>
-    108..117 'Some("x")': Option<&str>
-    113..116 '"x"': &str
-    123..135 'Option::Some': Some<&str>(&str) -> Option<&str>
-    123..140 'Option...e("x")': Option<&str>
-    136..139 '"x"': &str
-    146..150 'None': Option<{unknown}>
-    160..161 'x': Option<i64>
-    177..181 'None': Option<i64>
+    75..183 '{     ...one; }': ()
+    81..82 'A': A<i32>(i32) -> A<i32>
+    81..86 'A(42)': A<i32>
+    83..85 '42': i32
+    92..93 'A': A<u128>(u128) -> A<u128>
+    92..101 'A(42u128)': A<u128>
+    94..100 '42u128': u128
+    107..111 'Some': Some<&str>(&str) -> Option<&str>
+    107..116 'Some("x")': Option<&str>
+    112..115 '"x"': &str
+    122..134 'Option::Some': Some<&str>(&str) -> Option<&str>
+    122..139 'Option...e("x")': Option<&str>
+    135..138 '"x"': &str
+    145..149 'None': Option<{unknown}>
+    159..160 'x': Option<i64>
+    176..180 'None': Option<i64>
     "###
     );
 }
@@ -1308,20 +1308,20 @@ fn test() {
 }
 "#),
         @r###"
-    10..11 't': T
-    21..26 '{ t }': T
-    23..24 't': T
-    38..98 '{     ...(1); }': ()
-    44..46 'id': fn id<u32>(u32) -> u32
-    44..52 'id(1u32)': u32
-    47..51 '1u32': u32
-    58..68 'id::<i128>': fn id<i128>(i128) -> i128
-    58..71 'id::<i128>(1)': i128
-    69..70 '1': i128
-    81..82 'x': u64
-    90..92 'id': fn id<u64>(u64) -> u64
-    90..95 'id(1)': u64
-    93..94 '1': u64
+    9..10 't': T
+    20..25 '{ t }': T
+    22..23 't': T
+    37..97 '{     ...(1); }': ()
+    43..45 'id': fn id<u32>(u32) -> u32
+    43..51 'id(1u32)': u32
+    46..50 '1u32': u32
+    57..67 'id::<i128>': fn id<i128>(i128) -> i128
+    57..70 'id::<i128>(1)': i128
+    68..69 '1': i128
+    80..81 'x': u64
+    89..91 'id': fn id<u64>(u64) -> u64
+    89..94 'id(1)': u64
+    92..93 '1': u64
     "###
     );
 }
@@ -1355,38 +1355,38 @@ fn test() -> i128 {
 }
 "#),
         @r###"
-    74..78 'self': A<X, Y>
-    85..107 '{     ...     }': X
-    95..99 'self': A<X, Y>
-    95..101 'self.x': X
-    117..121 'self': A<X, Y>
-    128..150 '{     ...     }': Y
-    138..142 'self': A<X, Y>
-    138..144 'self.y': Y
-    163..167 'self': A<X, Y>
-    169..170 't': T
-    188..223 '{     ...     }': (X, Y, T)
-    198..217 '(self.....y, t)': (X, Y, T)
-    199..203 'self': A<X, Y>
-    199..205 'self.x': X
-    207..211 'self': A<X, Y>
-    207..213 'self.y': Y
-    215..216 't': T
-    245..342 '{     ...(1); }': ()
-    255..256 'a': A<u64, i64>
-    259..281 'A { x:...1i64 }': A<u64, i64>
-    266..270 '1u64': u64
-    275..279 '1i64': i64
-    287..288 'a': A<u64, i64>
-    287..292 'a.x()': u64
-    298..299 'a': A<u64, i64>
-    298..303 'a.y()': i64
-    309..310 'a': A<u64, i64>
-    309..319 'a.z(1i128)': (u64, i64, i128)
-    313..318 '1i128': i128
-    325..326 'a': A<u64, i64>
-    325..339 'a.z::<u128>(1)': (u64, i64, u128)
-    337..338 '1': u128
+    73..77 'self': A<X, Y>
+    84..106 '{     ...     }': X
+    94..98 'self': A<X, Y>
+    94..100 'self.x': X
+    116..120 'self': A<X, Y>
+    127..149 '{     ...     }': Y
+    137..141 'self': A<X, Y>
+    137..143 'self.y': Y
+    162..166 'self': A<X, Y>
+    168..169 't': T
+    187..222 '{     ...     }': (X, Y, T)
+    197..216 '(self.....y, t)': (X, Y, T)
+    198..202 'self': A<X, Y>
+    198..204 'self.x': X
+    206..210 'self': A<X, Y>
+    206..212 'self.y': Y
+    214..215 't': T
+    244..341 '{     ...(1); }': ()
+    254..255 'a': A<u64, i64>
+    258..280 'A { x:...1i64 }': A<u64, i64>
+    265..269 '1u64': u64
+    274..278 '1i64': i64
+    286..287 'a': A<u64, i64>
+    286..291 'a.x()': u64
+    297..298 'a': A<u64, i64>
+    297..302 'a.y()': i64
+    308..309 'a': A<u64, i64>
+    308..318 'a.z(1i128)': (u64, i64, i128)
+    312..317 '1i128': i128
+    324..325 'a': A<u64, i64>
+    324..338 'a.z::<u128>(1)': (u64, i64, u128)
+    336..337 '1': u128
     "###
     );
 }
@@ -1408,15 +1408,15 @@ fn test(o: Option<u32>) {
 }
 "#),
         @r###"
-    78..82 'self': &Option<T>
-    98..100 '{}': ()
-    111..112 'o': Option<u32>
-    127..165 '{     ...f(); }': ()
-    133..146 '(&o).as_ref()': Option<&u32>
-    134..136 '&o': &Option<u32>
-    135..136 'o': Option<u32>
-    152..153 'o': Option<u32>
-    152..162 'o.as_ref()': Option<&u32>
+    77..81 'self': &Option<T>
+    97..99 '{}': ()
+    110..111 'o': Option<u32>
+    126..164 '{     ...f(); }': ()
+    132..145 '(&o).as_ref()': Option<&u32>
+    133..135 '&o': &Option<u32>
+    134..135 'o': Option<u32>
+    151..152 'o': Option<u32>
+    151..161 'o.as_ref()': Option<&u32>
     "###
     );
 }
@@ -1445,35 +1445,35 @@ fn test() -> i128 {
 }
 "#),
         @r###"
-    53..57 'self': A<T2>
-    65..87 '{     ...     }': T2
-    75..79 'self': A<T2>
-    75..81 'self.x': T2
-    99..100 't': T
-    110..115 '{ t }': T
-    112..113 't': T
-    135..261 '{     ....x() }': i128
-    146..147 'x': i128
-    150..151 '1': i128
-    162..163 'y': i128
-    166..168 'id': fn id<i128>(i128) -> i128
-    166..171 'id(x)': i128
-    169..170 'x': i128
-    182..183 'a': A<i128>
-    186..200 'A { x: id(y) }': A<i128>
-    193..195 'id': fn id<i128>(i128) -> i128
-    193..198 'id(y)': i128
-    196..197 'y': i128
-    211..212 'z': i128
-    215..217 'id': fn id<i128>(i128) -> i128
-    215..222 'id(a.x)': i128
-    218..219 'a': A<i128>
-    218..221 'a.x': i128
-    233..234 'b': A<i128>
-    237..247 'A { x: z }': A<i128>
-    244..245 'z': i128
-    254..255 'b': A<i128>
-    254..259 'b.x()': i128
+    52..56 'self': A<T2>
+    64..86 '{     ...     }': T2
+    74..78 'self': A<T2>
+    74..80 'self.x': T2
+    98..99 't': T
+    109..114 '{ t }': T
+    111..112 't': T
+    134..260 '{     ....x() }': i128
+    145..146 'x': i128
+    149..150 '1': i128
+    161..162 'y': i128
+    165..167 'id': fn id<i128>(i128) -> i128
+    165..170 'id(x)': i128
+    168..169 'x': i128
+    181..182 'a': A<i128>
+    185..199 'A { x: id(y) }': A<i128>
+    192..194 'id': fn id<i128>(i128) -> i128
+    192..197 'id(y)': i128
+    195..196 'y': i128
+    210..211 'z': i128
+    214..216 'id': fn id<i128>(i128) -> i128
+    214..221 'id(a.x)': i128
+    217..218 'a': A<i128>
+    217..220 'a.x': i128
+    232..233 'b': A<i128>
+    236..246 'A { x: z }': A<i128>
+    243..244 'z': i128
+    253..254 'b': A<i128>
+    253..258 'b.x()': i128
     "###
     );
 }
@@ -1511,16 +1511,16 @@ fn test() {
 }
 "#),
         @r###"
-    52..53 '1': u32
-    105..106 '2': u32
-    213..214 '5': u32
-    229..307 '{     ...:ID; }': ()
-    239..240 'x': u32
-    243..254 'Struct::FOO': u32
-    264..265 'y': u32
-    268..277 'Enum::BAR': u32
-    287..288 'z': u32
-    291..304 'TraitTest::ID': u32
+    51..52 '1': u32
+    104..105 '2': u32
+    212..213 '5': u32
+    228..306 '{     ...:ID; }': ()
+    238..239 'x': u32
+    242..253 'Struct::FOO': u32
+    263..264 'y': u32
+    267..276 'Enum::BAR': u32
+    286..287 'z': u32
+    290..303 'TraitTest::ID': u32
     "###
     );
 }
@@ -1543,22 +1543,22 @@ fn test(x: Foo, y: Bar<&str>, z: Baz<i8, u8>) {
 }
 "#),
         @r###"
-    116..117 'x': A<u32, i128>
-    124..125 'y': A<&str, u128>
-    138..139 'z': A<u8, i8>
-    154..211 '{     ...z.y; }': ()
-    160..161 'x': A<u32, i128>
-    160..163 'x.x': u32
-    169..170 'x': A<u32, i128>
-    169..172 'x.y': i128
-    178..179 'y': A<&str, u128>
-    178..181 'y.x': &str
-    187..188 'y': A<&str, u128>
-    187..190 'y.y': u128
-    196..197 'z': A<u8, i8>
-    196..199 'z.x': u8
-    205..206 'z': A<u8, i8>
-    205..208 'z.y': i8
+    115..116 'x': A<u32, i128>
+    123..124 'y': A<&str, u128>
+    137..138 'z': A<u8, i8>
+    153..210 '{     ...z.y; }': ()
+    159..160 'x': A<u32, i128>
+    159..162 'x.x': u32
+    168..169 'x': A<u32, i128>
+    168..171 'x.y': i128
+    177..178 'y': A<&str, u128>
+    177..180 'y.x': &str
+    186..187 'y': A<&str, u128>
+    186..189 'y.y': u128
+    195..196 'z': A<u8, i8>
+    195..198 'z.x': u8
+    204..205 'z': A<u8, i8>
+    204..207 'z.y': i8
     "###
     )
 }
@@ -1573,8 +1573,8 @@ type Bar = A<Bar>;
 fn test(x: Foo) {}
 "#),
         @r###"
-    59..60 'x': {unknown}
-    67..69 '{}': ()
+    58..59 'x': {unknown}
+    66..68 '{}': ()
     "###
     )
 }
@@ -1599,26 +1599,26 @@ fn test() {
 }
 "#),
         @r###"
-    10..11 'x': T
-    21..30 '{     x }': T
-    27..28 'x': T
-    44..45 'x': &T
-    56..66 '{     *x }': T
-    62..64 '*x': T
-    63..64 'x': &T
-    78..158 '{     ...(1); }': ()
-    88..89 'y': u32
-    92..97 '10u32': u32
-    103..105 'id': fn id<u32>(u32) -> u32
-    103..108 'id(y)': u32
-    106..107 'y': u32
-    118..119 'x': bool
-    128..133 'clone': fn clone<bool>(&bool) -> bool
-    128..136 'clone(z)': bool
-    134..135 'z': &bool
-    142..152 'id::<i128>': fn id<i128>(i128) -> i128
-    142..155 'id::<i128>(1)': i128
-    153..154 '1': i128
+    9..10 'x': T
+    20..29 '{     x }': T
+    26..27 'x': T
+    43..44 'x': &T
+    55..65 '{     *x }': T
+    61..63 '*x': T
+    62..63 'x': &T
+    77..157 '{     ...(1); }': ()
+    87..88 'y': u32
+    91..96 '10u32': u32
+    102..104 'id': fn id<u32>(u32) -> u32
+    102..107 'id(y)': u32
+    105..106 'y': u32
+    117..118 'x': bool
+    127..132 'clone': fn clone<bool>(&bool) -> bool
+    127..135 'clone(z)': bool
+    133..134 'z': &bool
+    141..151 'id::<i128>': fn id<i128>(i128) -> i128
+    141..154 'id::<i128>(1)': i128
+    152..153 '1': i128
     "###
     );
 }
@@ -1638,16 +1638,16 @@ fn test() {
 }
 "#),
         @r###"
-    49..50 '0': u32
-    80..83 '101': u32
-    95..213 '{     ...NST; }': ()
-    138..139 'x': u32
-    142..153 'LOCAL_CONST': u32
-    163..164 'z': u32
-    167..179 'GLOBAL_CONST': u32
-    189..191 'id': u32
-    194..210 'Foo::A..._CONST': u32
-    126..128 '99': u32
+    48..49 '0': u32
+    79..82 '101': u32
+    94..212 '{     ...NST; }': ()
+    137..138 'x': u32
+    141..152 'LOCAL_CONST': u32
+    162..163 'z': u32
+    166..178 'GLOBAL_CONST': u32
+    188..190 'id': u32
+    193..209 'Foo::A..._CONST': u32
+    125..127 '99': u32
     "###
     );
 }
@@ -1668,19 +1668,19 @@ fn test() {
 }
 "#),
         @r###"
-    29..32 '101': u32
-    70..73 '101': u32
-    85..280 '{     ...MUT; }': ()
-    173..174 'x': u32
-    177..189 'LOCAL_STATIC': u32
-    199..200 'y': u32
-    203..219 'LOCAL_...IC_MUT': u32
-    229..230 'z': u32
-    233..246 'GLOBAL_STATIC': u32
-    256..257 'w': u32
-    260..277 'GLOBAL...IC_MUT': u32
-    118..120 '99': u32
-    161..163 '99': u32
+    28..31 '101': u32
+    69..72 '101': u32
+    84..279 '{     ...MUT; }': ()
+    172..173 'x': u32
+    176..188 'LOCAL_STATIC': u32
+    198..199 'y': u32
+    202..218 'LOCAL_...IC_MUT': u32
+    228..229 'z': u32
+    232..245 'GLOBAL_STATIC': u32
+    255..256 'w': u32
+    259..276 'GLOBAL...IC_MUT': u32
+    117..119 '99': u32
+    160..162 '99': u32
     "###
     );
 }
@@ -1748,12 +1748,12 @@ fn foo() -> u32 {
 }
 "#),
         @r###"
-    17..59 '{     ...; }; }': ()
-    27..28 'x': || -> usize
-    31..56 '|| -> ...n 1; }': || -> usize
-    43..56 '{ return 1; }': usize
-    45..53 'return 1': !
-    52..53 '1': usize
+    16..58 '{     ...; }; }': ()
+    26..27 'x': || -> usize
+    30..55 '|| -> ...n 1; }': || -> usize
+    42..55 '{ return 1; }': usize
+    44..52 'return 1': !
+    51..52 '1': usize
     "###
     );
 }
@@ -1767,11 +1767,11 @@ fn foo() -> u32 {
 }
 "#),
         @r###"
-    17..48 '{     ...; }; }': ()
-    27..28 'x': || -> ()
-    31..45 '|| { return; }': || -> ()
-    34..45 '{ return; }': ()
-    36..42 'return': !
+    16..47 '{     ...; }; }': ()
+    26..27 'x': || -> ()
+    30..44 '|| { return; }': || -> ()
+    33..44 '{ return; }': ()
+    35..41 'return': !
     "###
     );
 }
@@ -1785,11 +1785,11 @@ fn foo() -> u32 {
 }
 "#),
         @r###"
-    17..47 '{     ..." }; }': ()
-    27..28 'x': || -> &str
-    31..44 '|| { "test" }': || -> &str
-    34..44 '{ "test" }': &str
-    36..42 '"test"': &str
+    16..46 '{     ..." }; }': ()
+    26..27 'x': || -> &str
+    30..43 '|| { "test" }': || -> &str
+    33..43 '{ "test" }': &str
+    35..41 '"test"': &str
     "###
     );
 }
@@ -1808,14 +1808,14 @@ fn main() {
 }
 "#),
         @r###"
-    48..121 '{     ...hod; }': ()
-    58..64 'vtable': Vtable
-    67..91 'Vtable...| {} }': Vtable
-    84..89 '|| {}': || -> ()
-    87..89 '{}': ()
-    101..102 'm': fn()
-    105..111 'vtable': Vtable
-    105..118 'vtable.method': fn()
+    47..120 '{     ...hod; }': ()
+    57..63 'vtable': Vtable
+    66..90 'Vtable...| {} }': Vtable
+    83..88 '|| {}': || -> ()
+    86..88 '{}': ()
+    100..101 'm': fn()
+    104..110 'vtable': Vtable
+    104..117 'vtable.method': fn()
     "###
     );
 }
@@ -1832,22 +1832,22 @@ fn main() {
 }
 "#),
         @r###"
-    11..131 '{     ...2 }; }': ()
-    21..22 'x': i32
-    32..38 '{ 92 }': i32
-    34..36 '92': i32
-    48..49 'y': {unknown}
-    58..80 '{ asyn...wait }': {unknown}
-    60..78 'async ....await': {unknown}
-    66..72 '{ () }': ()
-    68..70 '()': ()
-    90..91 'z': {unknown}
-    94..104 'try { () }': {unknown}
-    98..104 '{ () }': ()
-    100..102 '()': ()
-    114..115 't': i32
-    122..128 '{ 92 }': i32
-    124..126 '92': i32
+    10..130 '{     ...2 }; }': ()
+    20..21 'x': i32
+    31..37 '{ 92 }': i32
+    33..35 '92': i32
+    47..48 'y': {unknown}
+    57..79 '{ asyn...wait }': {unknown}
+    59..77 'async ....await': {unknown}
+    65..71 '{ () }': ()
+    67..69 '()': ()
+    89..90 'z': {unknown}
+    93..103 'try { () }': {unknown}
+    97..103 '{ () }': ()
+    99..101 '()': ()
+    113..114 't': i32
+    121..127 '{ 92 }': i32
+    123..125 '92': i32
     "###
     )
 }
@@ -1867,16 +1867,16 @@ fn test() {
 }
 "#),
         @r###"
-    60..130 '{     ...   } }': ()
-    70..77 'mut end': Option<bool>
-    80..84 'None': Option<bool>
-    90..128 'loop {...     }': !
-    95..128 '{     ...     }': ()
-    105..108 'end': Option<bool>
-    105..121 'end = ...(true)': ()
-    111..115 'Some': Some<bool>(bool) -> Option<bool>
-    111..121 'Some(true)': Option<bool>
-    116..120 'true': bool
+    59..129 '{     ...   } }': ()
+    69..76 'mut end': Option<bool>
+    79..83 'None': Option<bool>
+    89..127 'loop {...     }': !
+    94..127 '{     ...     }': ()
+    104..107 'end': Option<bool>
+    104..120 'end = ...(true)': ()
+    110..114 'Some': Some<bool>(bool) -> Option<bool>
+    110..120 'Some(true)': Option<bool>
+    115..119 'true': bool
     "###
     );
 }
@@ -1899,19 +1899,19 @@ fn test() {
 }
 "#),
         @r###"
-    60..169 '{     ...  }; }': ()
-    70..71 'x': Option<bool>
-    74..166 'loop {...     }': Option<bool>
-    79..166 '{     ...     }': ()
-    89..133 'if fal...     }': ()
-    92..97 'false': bool
-    98..133 '{     ...     }': ()
-    112..122 'break None': !
-    118..122 'None': Option<bool>
-    143..159 'break ...(true)': !
-    149..153 'Some': Some<bool>(bool) -> Option<bool>
-    149..159 'Some(true)': Option<bool>
-    154..158 'true': bool
+    59..168 '{     ...  }; }': ()
+    69..70 'x': Option<bool>
+    73..165 'loop {...     }': Option<bool>
+    78..165 '{     ...     }': ()
+    88..132 'if fal...     }': ()
+    91..96 'false': bool
+    97..132 '{     ...     }': ()
+    111..121 'break None': !
+    117..121 'None': Option<bool>
+    142..158 'break ...(true)': !
+    148..152 'Some': Some<bool>(bool) -> Option<bool>
+    148..158 'Some(true)': Option<bool>
+    153..157 'true': bool
     "###
     );
 }
@@ -1932,14 +1932,14 @@ fn test() {
 }
 "#),
         @r###"
-    60..137 '{     ...  }; }': ()
-    70..71 'x': ()
-    74..134 'loop {...     }': ()
-    79..134 '{     ...     }': ()
-    89..128 'if fal...     }': ()
-    92..97 'false': bool
-    98..128 '{     ...     }': ()
-    112..117 'break': !
+    59..136 '{     ...  }; }': ()
+    69..70 'x': ()
+    73..133 'loop {...     }': ()
+    78..133 '{     ...     }': ()
+    88..127 'if fal...     }': ()
+    91..96 'false': bool
+    97..127 '{     ...     }': ()
+    111..116 'break': !
     "###
     );
 }
@@ -1964,36 +1964,36 @@ fn foo() {
 }
 "#),
         @r###"
-    10..336 '{     ...  }; }': ()
-    20..22 '_x': || -> bool
-    25..333 '|| 'ou...     }': || -> bool
-    28..333 ''outer...     }': bool
-    41..333 '{     ...     }': ()
-    55..60 'inner': i8
-    63..301 ''inner...     }': i8
-    76..301 '{     ...     }': ()
-    94..95 'i': bool
-    98..114 'Defaul...efault': {unknown}
-    98..116 'Defaul...ault()': bool
-    130..270 'if (br...     }': ()
-    134..148 'break 'outer i': !
-    147..148 'i': bool
-    150..209 '{     ...     }': ()
-    168..194 'loop {...5i8; }': !
-    173..194 '{ brea...5i8; }': ()
-    175..191 'break ...er 5i8': !
-    188..191 '5i8': i8
-    215..270 'if tru...     }': ()
-    218..222 'true': bool
-    223..270 '{     ...     }': ()
-    241..255 'break 'inner 6': !
-    254..255 '6': i8
-    283..290 'break 7': !
-    289..290 '7': i8
-    311..326 'break inner < 8': !
-    317..322 'inner': i8
-    317..326 'inner < 8': bool
-    325..326 '8': i8
+    9..335 '{     ...  }; }': ()
+    19..21 '_x': || -> bool
+    24..332 '|| 'ou...     }': || -> bool
+    27..332 ''outer...     }': bool
+    40..332 '{     ...     }': ()
+    54..59 'inner': i8
+    62..300 ''inner...     }': i8
+    75..300 '{     ...     }': ()
+    93..94 'i': bool
+    97..113 'Defaul...efault': {unknown}
+    97..115 'Defaul...ault()': bool
+    129..269 'if (br...     }': ()
+    133..147 'break 'outer i': !
+    146..147 'i': bool
+    149..208 '{     ...     }': ()
+    167..193 'loop {...5i8; }': !
+    172..193 '{ brea...5i8; }': ()
+    174..190 'break ...er 5i8': !
+    187..190 '5i8': i8
+    214..269 'if tru...     }': ()
+    217..221 'true': bool
+    222..269 '{     ...     }': ()
+    240..254 'break 'inner 6': !
+    253..254 '6': i8
+    282..289 'break 7': !
+    288..289 '7': i8
+    310..325 'break inner < 8': !
+    316..321 'inner': i8
+    316..325 'inner < 8': bool
+    324..325 '8': i8
     "###
     );
 }
@@ -2022,35 +2022,35 @@ fn test(t1: Thing, t2: OtherThing, t3: Thing<i32>, t4: OtherThing<i32>) {
 }
 "#),
         @r###"
-    98..100 't1': Thing<()>
-    109..111 't2': OtherThing<()>
-    125..127 't3': Thing<i32>
-    141..143 't4': OtherThing<i32>
-    162..385 '{     ...   } }': ()
-    168..170 't1': Thing<()>
-    168..172 't1.t': ()
-    178..180 't3': Thing<i32>
-    178..182 't3.t': i32
-    188..283 'match ...     }': ()
-    194..196 't2': OtherThing<()>
-    207..228 'OtherT... { t }': OtherThing<()>
-    225..226 't': ()
-    232..238 '{ t; }': ()
-    234..235 't': ()
-    248..266 'OtherT...Two(t)': OtherThing<()>
-    264..265 't': ()
-    270..276 '{ t; }': ()
-    272..273 't': ()
-    288..383 'match ...     }': ()
-    294..296 't4': OtherThing<i32>
-    307..328 'OtherT... { t }': OtherThing<i32>
-    325..326 't': i32
-    332..338 '{ t; }': ()
-    334..335 't': i32
-    348..366 'OtherT...Two(t)': OtherThing<i32>
-    364..365 't': i32
-    370..376 '{ t; }': ()
-    372..373 't': i32
+    97..99 't1': Thing<()>
+    108..110 't2': OtherThing<()>
+    124..126 't3': Thing<i32>
+    140..142 't4': OtherThing<i32>
+    161..384 '{     ...   } }': ()
+    167..169 't1': Thing<()>
+    167..171 't1.t': ()
+    177..179 't3': Thing<i32>
+    177..181 't3.t': i32
+    187..282 'match ...     }': ()
+    193..195 't2': OtherThing<()>
+    206..227 'OtherT... { t }': OtherThing<()>
+    224..225 't': ()
+    231..237 '{ t; }': ()
+    233..234 't': ()
+    247..265 'OtherT...Two(t)': OtherThing<()>
+    263..264 't': ()
+    269..275 '{ t; }': ()
+    271..272 't': ()
+    287..382 'match ...     }': ()
+    293..295 't4': OtherThing<i32>
+    306..327 'OtherT... { t }': OtherThing<i32>
+    324..325 't': i32
+    331..337 '{ t; }': ()
+    333..334 't': i32
+    347..365 'OtherT...Two(t)': OtherThing<i32>
+    363..364 't': i32
+    369..375 '{ t; }': ()
+    371..372 't': i32
     "###
     );
 }
@@ -2078,30 +2078,30 @@ fn test() {
 }
 "#),
         @r###"
-    100..320 '{     ...32); }': ()
-    110..111 'x': Thing<!>
-    114..134 'Thing ...p {} }': Thing<!>
-    125..132 'loop {}': !
-    130..132 '{}': ()
-    144..145 'y': Thing<()>
-    148..163 'Thing { t: () }': Thing<()>
-    159..161 '()': ()
-    173..174 'z': Thing<i32>
-    177..194 'Thing ...1i32 }': Thing<i32>
-    188..192 '1i32': i32
-    200..241 'if let...     }': ()
-    207..218 'Thing { t }': Thing<i32>
-    215..216 't': i32
-    221..222 'z': Thing<i32>
-    223..241 '{     ...     }': ()
-    233..234 't': i32
-    251..252 'a': OtherThing<i32>
-    255..282 'OtherT...1i32 }': OtherThing<i32>
-    276..280 '1i32': i32
-    292..293 'b': OtherThing<i32>
-    296..311 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
-    296..317 'OtherT...(1i32)': OtherThing<i32>
-    312..316 '1i32': i32
+    99..319 '{     ...32); }': ()
+    109..110 'x': Thing<!>
+    113..133 'Thing ...p {} }': Thing<!>
+    124..131 'loop {}': !
+    129..131 '{}': ()
+    143..144 'y': Thing<()>
+    147..162 'Thing { t: () }': Thing<()>
+    158..160 '()': ()
+    172..173 'z': Thing<i32>
+    176..193 'Thing ...1i32 }': Thing<i32>
+    187..191 '1i32': i32
+    199..240 'if let...     }': ()
+    206..217 'Thing { t }': Thing<i32>
+    214..215 't': i32
+    220..221 'z': Thing<i32>
+    222..240 '{     ...     }': ()
+    232..233 't': i32
+    250..251 'a': OtherThing<i32>
+    254..281 'OtherT...1i32 }': OtherThing<i32>
+    275..279 '1i32': i32
+    291..292 'b': OtherThing<i32>
+    295..310 'OtherThing::Two': Two<i32>(i32) -> OtherThing<i32>
+    295..316 'OtherT...(1i32)': OtherThing<i32>
+    311..315 '1i32': i32
     "###
     );
 }