From d016cb486738c1ab2574a322924183fa8a870b06 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 24 Jun 2020 00:48:38 +0200 Subject: Use only one code-path for parsing fixtures This removes leading newlines everywhere, shifting all ranges in tests by one --- crates/ra_hir_ty/src/tests/simple.rs | 1654 +++++++++++++++++----------------- 1 file changed, 827 insertions(+), 827 deletions(-) (limited to 'crates/ra_hir_ty/src/tests/simple.rs') 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 { } "#, ), @r###" - 63..93 '{ ... }': () - 73..86 'Self { x: 1 }': S - 83..84 '1': u32 + 49..79 '{ ... }': () + 59..72 'Self { x: 1 }': S + 69..70 '1': u32 "###); } @@ -85,9 +85,9 @@ fn foo() { "#, ), @r###" - 64..84 '{ ...1 }; }': () - 70..81 'SS { x: 1 }': S - 78..79 '1': u32 + 50..70 '{ ...1 }; }': () + 56..67 'SS { x: 1 }': S + 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 '::foo': fn foo() -> i32 - 80..90 '::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 '::foo': fn foo() -> i32 + 79..89 '::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 - 151..174 '{ ... }': &T - 161..168 '&self.0': &T - 162..166 'self': &A - 162..168 'self.0': T - 255..259 'self': &B - 278..301 '{ ... }': &T - 288..295 '&self.0': &T - 289..293 'self': &B - 289..295 'self.0': T - 315..353 '{ ...))); }': () - 325..326 't': &i32 - 329..335 'A::foo': fn foo(&A) -> &i32 - 329..350 'A::foo...42))))': &i32 - 336..349 '&&B(B(A(42)))': &&B>> - 337..349 '&B(B(A(42)))': &B>> - 338..339 'B': B>>(B>) -> B>> - 338..349 'B(B(A(42)))': B>> - 340..341 'B': B>(A) -> B> - 340..348 'B(A(42))': B> - 342..343 'A': A(i32) -> A - 342..347 'A(42)': A - 344..346 '42': i32 + 67..71 'self': &Self + 138..142 'self': &A + 150..173 '{ ... }': &T + 160..167 '&self.0': &T + 161..165 'self': &A + 161..167 'self.0': T + 254..258 'self': &B + 277..300 '{ ... }': &T + 287..294 '&self.0': &T + 288..292 'self': &B + 288..294 'self.0': T + 314..352 '{ ...))); }': () + 324..325 't': &i32 + 328..334 'A::foo': fn foo(&A) -> &i32 + 328..349 'A::foo...42))))': &i32 + 335..348 '&&B(B(A(42)))': &&B>> + 336..348 '&B(B(A(42)))': &B>> + 337..338 'B': B>>(B>) -> B>> + 337..348 'B(B(A(42)))': B>> + 339..340 'B': B>(A) -> B> + 339..347 'B(A(42))': B> + 341..342 'A': A(i32) -> A + 341..346 'A(42)': A + 343..345 '42': i32 "### ); } @@ -906,34 +906,34 @@ fn test(a: A) { } "#), @r###" - 68..72 'self': &Self - 144..148 'self': &A - 150..151 'x': &A - 166..187 '{ ... }': &T - 176..181 '&*x.0': &T - 177..181 '*x.0': T - 178..179 'x': &A - 178..181 'x.0': *mut T - 268..272 'self': &B - 291..314 '{ ... }': &T - 301..308 '&self.0': &T - 302..306 'self': &B - 302..308 'self.0': T - 326..327 'a': A - 337..383 '{ ...))); }': () - 347..348 't': &i32 - 351..352 'A': A(*mut i32) -> A - 351..365 'A(0 as *mut _)': A - 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>> - 371..379 '&B(B(a))': &B>> - 372..373 'B': B>>(B>) -> B>> - 372..379 'B(B(a))': B>> - 374..375 'B': B>(A) -> B> - 374..378 'B(a)': B> - 376..377 'a': A + 67..71 'self': &Self + 143..147 'self': &A + 149..150 'x': &A + 165..186 '{ ... }': &T + 175..180 '&*x.0': &T + 176..180 '*x.0': T + 177..178 'x': &A + 177..180 'x.0': *mut T + 267..271 'self': &B + 290..313 '{ ... }': &T + 300..307 '&self.0': &T + 301..305 'self': &B + 301..307 'self.0': T + 325..326 'a': A + 336..382 '{ ...))); }': () + 346..347 't': &i32 + 350..351 'A': A(*mut i32) -> A + 350..364 'A(0 as *mut _)': A + 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>> + 370..378 '&B(B(a))': &B>> + 371..372 'B': B>>(B>) -> B>> + 371..378 'B(B(a))': B>> + 373..374 'B': B>(A) -> B> + 373..377 'B(a)': B> + 375..376 'a': A "### ); } @@ -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, i: i32) { } "#), @r###" - 36..38 'a1': A - 48..49 'i': i32 - 56..147 '{ ...3.x; }': () - 62..64 'a1': A - 62..66 'a1.x': u32 - 76..78 'a2': A - 81..91 'A { x: i }': A - 88..89 'i': i32 - 97..99 'a2': A - 97..101 'a2.x': i32 - 111..113 'a3': A - 116..134 'A:: - 131..132 '1': i128 - 140..142 'a3': A - 140..144 'a3.x': i128 + 35..37 'a1': A + 47..48 'i': i32 + 55..146 '{ ...3.x; }': () + 61..63 'a1': A + 61..65 'a1.x': u32 + 75..77 'a2': A + 80..90 'A { x: i }': A + 87..88 'i': i32 + 96..98 'a2': A + 96..100 'a2.x': i32 + 110..112 'a3': A + 115..133 'A:: + 130..131 '1': i128 + 139..141 'a3': A + 139..143 'a3.x': i128 "### ); } @@ -1275,22 +1275,22 @@ fn test() { } "#), @r###" - 76..184 '{ ...one; }': () - 82..83 'A': A(i32) -> A - 82..87 'A(42)': A - 84..86 '42': i32 - 93..94 'A': A(u128) -> A - 93..102 'A(42u128)': A - 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 - 177..181 'None': Option + 75..183 '{ ...one; }': () + 81..82 'A': A(i32) -> A + 81..86 'A(42)': A + 83..85 '42': i32 + 92..93 'A': A(u128) -> A + 92..101 'A(42u128)': A + 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 + 176..180 'None': Option "### ); } @@ -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 - 44..52 'id(1u32)': u32 - 47..51 '1u32': u32 - 58..68 'id::': fn id(i128) -> i128 - 58..71 'id::(1)': i128 - 69..70 '1': i128 - 81..82 'x': u64 - 90..92 'id': fn id(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 + 43..51 'id(1u32)': u32 + 46..50 '1u32': u32 + 57..67 'id::': fn id(i128) -> i128 + 57..70 'id::(1)': i128 + 68..69 '1': i128 + 80..81 'x': u64 + 89..91 'id': fn id(u64) -> u64 + 89..94 'id(1)': u64 + 92..93 '1': u64 "### ); } @@ -1355,38 +1355,38 @@ fn test() -> i128 { } "#), @r###" - 74..78 'self': A - 85..107 '{ ... }': X - 95..99 'self': A - 95..101 'self.x': X - 117..121 'self': A - 128..150 '{ ... }': Y - 138..142 'self': A - 138..144 'self.y': Y - 163..167 'self': A - 169..170 't': T - 188..223 '{ ... }': (X, Y, T) - 198..217 '(self.....y, t)': (X, Y, T) - 199..203 'self': A - 199..205 'self.x': X - 207..211 'self': A - 207..213 'self.y': Y - 215..216 't': T - 245..342 '{ ...(1); }': () - 255..256 'a': A - 259..281 'A { x:...1i64 }': A - 266..270 '1u64': u64 - 275..279 '1i64': i64 - 287..288 'a': A - 287..292 'a.x()': u64 - 298..299 'a': A - 298..303 'a.y()': i64 - 309..310 'a': A - 309..319 'a.z(1i128)': (u64, i64, i128) - 313..318 '1i128': i128 - 325..326 'a': A - 325..339 'a.z::(1)': (u64, i64, u128) - 337..338 '1': u128 + 73..77 'self': A + 84..106 '{ ... }': X + 94..98 'self': A + 94..100 'self.x': X + 116..120 'self': A + 127..149 '{ ... }': Y + 137..141 'self': A + 137..143 'self.y': Y + 162..166 'self': A + 168..169 't': T + 187..222 '{ ... }': (X, Y, T) + 197..216 '(self.....y, t)': (X, Y, T) + 198..202 'self': A + 198..204 'self.x': X + 206..210 'self': A + 206..212 'self.y': Y + 214..215 't': T + 244..341 '{ ...(1); }': () + 254..255 'a': A + 258..280 'A { x:...1i64 }': A + 265..269 '1u64': u64 + 274..278 '1i64': i64 + 286..287 'a': A + 286..291 'a.x()': u64 + 297..298 'a': A + 297..302 'a.y()': i64 + 308..309 'a': A + 308..318 'a.z(1i128)': (u64, i64, i128) + 312..317 '1i128': i128 + 324..325 'a': A + 324..338 'a.z::(1)': (u64, i64, u128) + 336..337 '1': u128 "### ); } @@ -1408,15 +1408,15 @@ fn test(o: Option) { } "#), @r###" - 78..82 'self': &Option - 98..100 '{}': () - 111..112 'o': Option - 127..165 '{ ...f(); }': () - 133..146 '(&o).as_ref()': Option<&u32> - 134..136 '&o': &Option - 135..136 'o': Option - 152..153 'o': Option - 152..162 'o.as_ref()': Option<&u32> + 77..81 'self': &Option + 97..99 '{}': () + 110..111 'o': Option + 126..164 '{ ...f(); }': () + 132..145 '(&o).as_ref()': Option<&u32> + 133..135 '&o': &Option + 134..135 'o': Option + 151..152 'o': Option + 151..161 'o.as_ref()': Option<&u32> "### ); } @@ -1445,35 +1445,35 @@ fn test() -> i128 { } "#), @r###" - 53..57 'self': A - 65..87 '{ ... }': T2 - 75..79 'self': A - 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 - 166..171 'id(x)': i128 - 169..170 'x': i128 - 182..183 'a': A - 186..200 'A { x: id(y) }': A - 193..195 'id': fn id(i128) -> i128 - 193..198 'id(y)': i128 - 196..197 'y': i128 - 211..212 'z': i128 - 215..217 'id': fn id(i128) -> i128 - 215..222 'id(a.x)': i128 - 218..219 'a': A - 218..221 'a.x': i128 - 233..234 'b': A - 237..247 'A { x: z }': A - 244..245 'z': i128 - 254..255 'b': A - 254..259 'b.x()': i128 + 52..56 'self': A + 64..86 '{ ... }': T2 + 74..78 'self': A + 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 + 165..170 'id(x)': i128 + 168..169 'x': i128 + 181..182 'a': A + 185..199 'A { x: id(y) }': A + 192..194 'id': fn id(i128) -> i128 + 192..197 'id(y)': i128 + 195..196 'y': i128 + 210..211 'z': i128 + 214..216 'id': fn id(i128) -> i128 + 214..221 'id(a.x)': i128 + 217..218 'a': A + 217..220 'a.x': i128 + 232..233 'b': A + 236..246 'A { x: z }': A + 243..244 'z': i128 + 253..254 'b': A + 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) { } "#), @r###" - 116..117 'x': A - 124..125 'y': A<&str, u128> - 138..139 'z': A - 154..211 '{ ...z.y; }': () - 160..161 'x': A - 160..163 'x.x': u32 - 169..170 'x': A - 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 - 196..199 'z.x': u8 - 205..206 'z': A - 205..208 'z.y': i8 + 115..116 'x': A + 123..124 'y': A<&str, u128> + 137..138 'z': A + 153..210 '{ ...z.y; }': () + 159..160 'x': A + 159..162 'x.x': u32 + 168..169 'x': A + 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 + 195..198 'z.x': u8 + 204..205 'z': A + 204..207 'z.y': i8 "### ) } @@ -1573,8 +1573,8 @@ type Bar = A; 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 - 103..108 'id(y)': u32 - 106..107 'y': u32 - 118..119 'x': bool - 128..133 'clone': fn clone(&bool) -> bool - 128..136 'clone(z)': bool - 134..135 'z': &bool - 142..152 'id::': fn id(i128) -> i128 - 142..155 'id::(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 + 102..107 'id(y)': u32 + 105..106 'y': u32 + 117..118 'x': bool + 127..132 'clone': fn clone(&bool) -> bool + 127..135 'clone(z)': bool + 133..134 'z': &bool + 141..151 'id::': fn id(i128) -> i128 + 141..154 'id::(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 - 80..84 'None': Option - 90..128 'loop {... }': ! - 95..128 '{ ... }': () - 105..108 'end': Option - 105..121 'end = ...(true)': () - 111..115 'Some': Some(bool) -> Option - 111..121 'Some(true)': Option - 116..120 'true': bool + 59..129 '{ ... } }': () + 69..76 'mut end': Option + 79..83 'None': Option + 89..127 'loop {... }': ! + 94..127 '{ ... }': () + 104..107 'end': Option + 104..120 'end = ...(true)': () + 110..114 'Some': Some(bool) -> Option + 110..120 'Some(true)': Option + 115..119 'true': bool "### ); } @@ -1899,19 +1899,19 @@ fn test() { } "#), @r###" - 60..169 '{ ... }; }': () - 70..71 'x': Option - 74..166 'loop {... }': Option - 79..166 '{ ... }': () - 89..133 'if fal... }': () - 92..97 'false': bool - 98..133 '{ ... }': () - 112..122 'break None': ! - 118..122 'None': Option - 143..159 'break ...(true)': ! - 149..153 'Some': Some(bool) -> Option - 149..159 'Some(true)': Option - 154..158 'true': bool + 59..168 '{ ... }; }': () + 69..70 'x': Option + 73..165 'loop {... }': Option + 78..165 '{ ... }': () + 88..132 'if fal... }': () + 91..96 'false': bool + 97..132 '{ ... }': () + 111..121 'break None': ! + 117..121 'None': Option + 142..158 'break ...(true)': ! + 148..152 'Some': Some(bool) -> Option + 148..158 'Some(true)': Option + 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, t4: OtherThing) { } "#), @r###" - 98..100 't1': Thing<()> - 109..111 't2': OtherThing<()> - 125..127 't3': Thing - 141..143 't4': OtherThing - 162..385 '{ ... } }': () - 168..170 't1': Thing<()> - 168..172 't1.t': () - 178..180 't3': Thing - 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 - 307..328 'OtherT... { t }': OtherThing - 325..326 't': i32 - 332..338 '{ t; }': () - 334..335 't': i32 - 348..366 'OtherT...Two(t)': OtherThing - 364..365 't': i32 - 370..376 '{ t; }': () - 372..373 't': i32 + 97..99 't1': Thing<()> + 108..110 't2': OtherThing<()> + 124..126 't3': Thing + 140..142 't4': OtherThing + 161..384 '{ ... } }': () + 167..169 't1': Thing<()> + 167..171 't1.t': () + 177..179 't3': Thing + 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 + 306..327 'OtherT... { t }': OtherThing + 324..325 't': i32 + 331..337 '{ t; }': () + 333..334 't': i32 + 347..365 'OtherT...Two(t)': OtherThing + 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 - 177..194 'Thing ...1i32 }': Thing - 188..192 '1i32': i32 - 200..241 'if let... }': () - 207..218 'Thing { t }': Thing - 215..216 't': i32 - 221..222 'z': Thing - 223..241 '{ ... }': () - 233..234 't': i32 - 251..252 'a': OtherThing - 255..282 'OtherT...1i32 }': OtherThing - 276..280 '1i32': i32 - 292..293 'b': OtherThing - 296..311 'OtherThing::Two': Two(i32) -> OtherThing - 296..317 'OtherT...(1i32)': OtherThing - 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 + 176..193 'Thing ...1i32 }': Thing + 187..191 '1i32': i32 + 199..240 'if let... }': () + 206..217 'Thing { t }': Thing + 214..215 't': i32 + 220..221 'z': Thing + 222..240 '{ ... }': () + 232..233 't': i32 + 250..251 'a': OtherThing + 254..281 'OtherT...1i32 }': OtherThing + 275..279 '1i32': i32 + 291..292 'b': OtherThing + 295..310 'OtherThing::Two': Two(i32) -> OtherThing + 295..316 'OtherT...(1i32)': OtherThing + 311..315 '1i32': i32 "### ); } -- cgit v1.2.3