Merge #5014

5014: Use only one code-path for parsing fixtures r=matklad a=matklad

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



bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

1 files changed, 285 insertions, 285 deletions

diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index fe62587c0..8fa296137 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -30,54 +30,54 @@ fn test(x: &i32) {
 }
 "#),
         @r###"
-    9..10 'x': &i32
-    18..369 '{     ...o_x; }': ()
-    28..29 'y': &i32
-    32..33 'x': &i32
-    43..45 '&z': &i32
-    44..45 'z': i32
-    48..49 'x': &i32
-    59..60 'a': i32
-    63..64 'z': i32
-    74..80 '(c, d)': (i32, &str)
-    75..76 'c': i32
-    78..79 'd': &str
-    83..95 '(1, "hello")': (i32, &str)
-    84..85 '1': i32
-    87..94 '"hello"': &str
-    102..152 'for (e...     }': ()
-    106..112 '(e, f)': ({unknown}, {unknown})
-    107..108 'e': {unknown}
-    110..111 'f': {unknown}
-    116..125 'some_iter': {unknown}
-    126..152 '{     ...     }': ()
-    140..141 'g': {unknown}
-    144..145 'e': {unknown}
-    158..205 'if let...     }': ()
-    165..170 '[val]': [{unknown}]
-    166..169 'val': {unknown}
-    173..176 'opt': [{unknown}]
-    177..205 '{     ...     }': ()
-    191..192 'h': {unknown}
-    195..198 'val': {unknown}
-    215..221 'lambda': |u64, u64, i32| -> i32
-    224..256 '|a: u6...b; c }': |u64, u64, i32| -> i32
-    225..226 'a': u64
-    233..234 'b': u64
-    236..237 'c': i32
-    244..256 '{ a + b; c }': i32
-    246..247 'a': u64
-    246..251 'a + b': u64
-    250..251 'b': u64
-    253..254 'c': i32
-    267..279 'ref ref_to_x': &&i32
-    282..283 'x': &i32
-    293..302 'mut mut_x': &i32
-    305..306 'x': &i32
-    316..336 'ref mu...f_to_x': &mut &i32
-    339..340 'x': &i32
-    350..351 'k': &mut &i32
-    354..366 'mut_ref_to_x': &mut &i32
+    8..9 'x': &i32
+    17..368 '{     ...o_x; }': ()
+    27..28 'y': &i32
+    31..32 'x': &i32
+    42..44 '&z': &i32
+    43..44 'z': i32
+    47..48 'x': &i32
+    58..59 'a': i32
+    62..63 'z': i32
+    73..79 '(c, d)': (i32, &str)
+    74..75 'c': i32
+    77..78 'd': &str
+    82..94 '(1, "hello")': (i32, &str)
+    83..84 '1': i32
+    86..93 '"hello"': &str
+    101..151 'for (e...     }': ()
+    105..111 '(e, f)': ({unknown}, {unknown})
+    106..107 'e': {unknown}
+    109..110 'f': {unknown}
+    115..124 'some_iter': {unknown}
+    125..151 '{     ...     }': ()
+    139..140 'g': {unknown}
+    143..144 'e': {unknown}
+    157..204 'if let...     }': ()
+    164..169 '[val]': [{unknown}]
+    165..168 'val': {unknown}
+    172..175 'opt': [{unknown}]
+    176..204 '{     ...     }': ()
+    190..191 'h': {unknown}
+    194..197 'val': {unknown}
+    214..220 'lambda': |u64, u64, i32| -> i32
+    223..255 '|a: u6...b; c }': |u64, u64, i32| -> i32
+    224..225 'a': u64
+    232..233 'b': u64
+    235..236 'c': i32
+    243..255 '{ a + b; c }': i32
+    245..246 'a': u64
+    245..250 'a + b': u64
+    249..250 'b': u64
+    252..253 'c': i32
+    266..278 'ref ref_to_x': &&i32
+    281..282 'x': &i32
+    292..301 'mut mut_x': &i32
+    304..305 'x': &i32
+    315..335 'ref mu...f_to_x': &mut &i32
+    338..339 'x': &i32
+    349..350 'k': &mut &i32
+    353..365 'mut_ref_to_x': &mut &i32
     "###
     );
 }
@@ -97,47 +97,47 @@ fn test(x: &i32) {
 }
 "#, true),
         @r###"
-    18..29 '{ loop {} }': T
-    20..27 'loop {}': !
-    25..27 '{}': ()
-    38..39 'x': &i32
-    47..209 '{     ...) {} }': ()
-    53..76 'if let...y() {}': ()
-    60..65 '"foo"': &str
-    60..65 '"foo"': &str
-    68..71 'any': fn any<&str>() -> &str
-    68..73 'any()': &str
-    74..76 '{}': ()
-    81..100 'if let...y() {}': ()
-    88..89 '1': i32
-    88..89 '1': i32
-    92..95 'any': fn any<i32>() -> i32
-    92..97 'any()': i32
-    98..100 '{}': ()
-    105..127 'if let...y() {}': ()
-    112..116 '1u32': u32
-    112..116 '1u32': u32
-    119..122 'any': fn any<u32>() -> u32
-    119..124 'any()': u32
-    125..127 '{}': ()
-    132..154 'if let...y() {}': ()
-    139..143 '1f32': f32
-    139..143 '1f32': f32
-    146..149 'any': fn any<f32>() -> f32
-    146..151 'any()': f32
-    152..154 '{}': ()
-    159..180 'if let...y() {}': ()
-    166..169 '1.0': f64
-    166..169 '1.0': f64
-    172..175 'any': fn any<f64>() -> f64
-    172..177 'any()': f64
-    178..180 '{}': ()
-    185..207 'if let...y() {}': ()
-    192..196 'true': bool
-    192..196 'true': bool
-    199..202 'any': fn any<bool>() -> bool
-    199..204 'any()': bool
-    205..207 '{}': ()
+    17..28 '{ loop {} }': T
+    19..26 'loop {}': !
+    24..26 '{}': ()
+    37..38 'x': &i32
+    46..208 '{     ...) {} }': ()
+    52..75 'if let...y() {}': ()
+    59..64 '"foo"': &str
+    59..64 '"foo"': &str
+    67..70 'any': fn any<&str>() -> &str
+    67..72 'any()': &str
+    73..75 '{}': ()
+    80..99 'if let...y() {}': ()
+    87..88 '1': i32
+    87..88 '1': i32
+    91..94 'any': fn any<i32>() -> i32
+    91..96 'any()': i32
+    97..99 '{}': ()
+    104..126 'if let...y() {}': ()
+    111..115 '1u32': u32
+    111..115 '1u32': u32
+    118..121 'any': fn any<u32>() -> u32
+    118..123 'any()': u32
+    124..126 '{}': ()
+    131..153 'if let...y() {}': ()
+    138..142 '1f32': f32
+    138..142 '1f32': f32
+    145..148 'any': fn any<f32>() -> f32
+    145..150 'any()': f32
+    151..153 '{}': ()
+    158..179 'if let...y() {}': ()
+    165..168 '1.0': f64
+    165..168 '1.0': f64
+    171..174 'any': fn any<f64>() -> f64
+    171..176 'any()': f64
+    177..179 '{}': ()
+    184..206 'if let...y() {}': ()
+    191..195 'true': bool
+    191..195 'true': bool
+    198..201 'any': fn any<bool>() -> bool
+    198..203 'any()': bool
+    204..206 '{}': ()
     "###
     );
 }
@@ -152,16 +152,16 @@ fn test(x: &i32) {
 }
 "#, true),
         @r###"
-    9..10 'x': &i32
-    18..76 '{     ...2 {} }': ()
-    24..46 'if let...u32 {}': ()
-    31..36 '1..76': u32
-    39..43 '2u32': u32
-    44..46 '{}': ()
-    51..74 'if let...u32 {}': ()
-    58..64 '1..=76': u32
-    67..71 '2u32': u32
-    72..74 '{}': ()
+    8..9 'x': &i32
+    17..75 '{     ...2 {} }': ()
+    23..45 'if let...u32 {}': ()
+    30..35 '1..76': u32
+    38..42 '2u32': u32
+    43..45 '{}': ()
+    50..73 'if let...u32 {}': ()
+    57..63 '1..=76': u32
+    66..70 '2u32': u32
+    71..73 '{}': ()
     "###
     );
 }
@@ -178,19 +178,19 @@ fn test() {
 }
 "#),
     @r###"
-    28..79 '{     ...(1); }': ()
-    38..42 'A(n)': A<i32>
-    40..41 'n': &i32
-    45..50 '&A(1)': &A<i32>
-    46..47 'A': A<i32>(i32) -> A<i32>
-    46..50 'A(1)': A<i32>
-    48..49 '1': i32
-    60..64 'A(n)': A<i32>
-    62..63 'n': &mut i32
-    67..76 '&mut A(1)': &mut A<i32>
-    72..73 'A': A<i32>(i32) -> A<i32>
-    72..76 'A(1)': A<i32>
-    74..75 '1': i32
+    27..78 '{     ...(1); }': ()
+    37..41 'A(n)': A<i32>
+    39..40 'n': &i32
+    44..49 '&A(1)': &A<i32>
+    45..46 'A': A<i32>(i32) -> A<i32>
+    45..49 'A(1)': A<i32>
+    47..48 '1': i32
+    59..63 'A(n)': A<i32>
+    61..62 'n': &mut i32
+    66..75 '&mut A(1)': &mut A<i32>
+    71..72 'A': A<i32>(i32) -> A<i32>
+    71..75 'A(1)': A<i32>
+    73..74 '1': i32
     "###
     );
 }
@@ -206,18 +206,18 @@ fn test() {
 }
 "#),
     @r###"
-    11..57 '{     ...= v; }': ()
-    21..22 'v': &(i32, &i32)
-    25..33 '&(1, &2)': &(i32, &i32)
-    26..33 '(1, &2)': (i32, &i32)
-    27..28 '1': i32
-    30..32 '&2': &i32
-    31..32 '2': i32
-    43..50 '(_, &w)': (i32, &i32)
-    44..45 '_': i32
-    47..49 '&w': &i32
-    48..49 'w': i32
-    53..54 'v': &(i32, &i32)
+    10..56 '{     ...= v; }': ()
+    20..21 'v': &(i32, &i32)
+    24..32 '&(1, &2)': &(i32, &i32)
+    25..32 '(1, &2)': (i32, &i32)
+    26..27 '1': i32
+    29..31 '&2': &i32
+    30..31 '2': i32
+    42..49 '(_, &w)': (i32, &i32)
+    43..44 '_': i32
+    46..48 '&w': &i32
+    47..48 'w': i32
+    52..53 'v': &(i32, &i32)
     "###
     );
 }
@@ -242,30 +242,30 @@ fn test() {
 }
 "#),
     @r###"
-    11..210 '{     ...   } }': ()
-    21..26 'slice': &[f64]
-    37..43 '&[0.0]': &[f64; _]
-    38..43 '[0.0]': [f64; _]
-    39..42 '0.0': f64
-    49..208 'match ...     }': ()
-    55..60 'slice': &[f64]
-    71..74 '&[]': &[f64]
-    72..74 '[]': [f64]
-    78..80 '{}': ()
-    90..94 '&[a]': &[f64]
-    91..94 '[a]': [f64]
-    92..93 'a': f64
-    98..124 '{     ...     }': ()
-    112..113 'a': f64
-    134..141 '&[b, c]': &[f64]
-    135..141 '[b, c]': [f64]
-    136..137 'b': f64
-    139..140 'c': f64
-    145..186 '{     ...     }': ()
-    159..160 'b': f64
-    174..175 'c': f64
-    195..196 '_': &[f64]
-    200..202 '{}': ()
+    10..209 '{     ...   } }': ()
+    20..25 'slice': &[f64]
+    36..42 '&[0.0]': &[f64; _]
+    37..42 '[0.0]': [f64; _]
+    38..41 '0.0': f64
+    48..207 'match ...     }': ()
+    54..59 'slice': &[f64]
+    70..73 '&[]': &[f64]
+    71..73 '[]': [f64]
+    77..79 '{}': ()
+    89..93 '&[a]': &[f64]
+    90..93 '[a]': [f64]
+    91..92 'a': f64
+    97..123 '{     ...     }': ()
+    111..112 'a': f64
+    133..140 '&[b, c]': &[f64]
+    134..140 '[b, c]': [f64]
+    135..136 'b': f64
+    138..139 'c': f64
+    144..185 '{     ...     }': ()
+    158..159 'b': f64
+    173..174 'c': f64
+    194..195 '_': &[f64]
+    199..201 '{}': ()
     "###
     );
 }
@@ -288,25 +288,25 @@ fn test() {
 }
 "#),
     @r###"
-    11..180 '{     ...   } }': ()
-    21..24 'arr': [f64; _]
-    37..47 '[0.0, 1.0]': [f64; _]
-    38..41 '0.0': f64
-    43..46 '1.0': f64
-    53..178 'match ...     }': ()
-    59..62 'arr': [f64; _]
-    73..81 '[1.0, a]': [f64; _]
-    74..77 '1.0': f64
-    74..77 '1.0': f64
-    79..80 'a': f64
-    85..111 '{     ...     }': ()
-    99..100 'a': f64
-    121..127 '[b, c]': [f64; _]
-    122..123 'b': f64
-    125..126 'c': f64
-    131..172 '{     ...     }': ()
-    145..146 'b': f64
-    160..161 'c': f64
+    10..179 '{     ...   } }': ()
+    20..23 'arr': [f64; _]
+    36..46 '[0.0, 1.0]': [f64; _]
+    37..40 '0.0': f64
+    42..45 '1.0': f64
+    52..177 'match ...     }': ()
+    58..61 'arr': [f64; _]
+    72..80 '[1.0, a]': [f64; _]
+    73..76 '1.0': f64
+    73..76 '1.0': f64
+    78..79 'a': f64
+    84..110 '{     ...     }': ()
+    98..99 'a': f64
+    120..126 '[b, c]': [f64; _]
+    121..122 'b': f64
+    124..125 'c': f64
+    130..171 '{     ...     }': ()
+    144..145 'b': f64
+    159..160 'c': f64
     "###
     );
 }
@@ -339,31 +339,31 @@ fn test() {
 }
 "#),
         @r###"
-    68..289 '{     ...  d; }': ()
-    78..79 'e': E
-    82..95 'E::A { x: 3 }': E
-    92..93 '3': usize
-    106..113 'S(y, z)': S
-    108..109 'y': u32
-    111..112 'z': E
-    116..119 'foo': S
-    129..148 'E::A {..._var }': E
-    139..146 'new_var': usize
-    151..152 'e': E
-    159..245 'match ...     }': usize
-    165..166 'e': E
-    177..187 'E::A { x }': E
-    184..185 'x': usize
-    191..192 'x': usize
-    202..206 'E::B': E
-    210..213 'foo': bool
-    217..218 '1': usize
-    228..232 'E::B': E
-    236..238 '10': usize
-    256..275 'ref d ...{ .. }': &E
-    264..275 'E::A { .. }': E
-    278..279 'e': E
-    285..286 'd': &E
+    67..288 '{     ...  d; }': ()
+    77..78 'e': E
+    81..94 'E::A { x: 3 }': E
+    91..92 '3': usize
+    105..112 'S(y, z)': S
+    107..108 'y': u32
+    110..111 'z': E
+    115..118 'foo': S
+    128..147 'E::A {..._var }': E
+    138..145 'new_var': usize
+    150..151 'e': E
+    158..244 'match ...     }': usize
+    164..165 'e': E
+    176..186 'E::A { x }': E
+    183..184 'x': usize
+    190..191 'x': usize
+    201..205 'E::B': E
+    209..212 'foo': bool
+    216..217 '1': usize
+    227..231 'E::B': E
+    235..237 '10': usize
+    255..274 'ref d ...{ .. }': &E
+    263..274 'E::A { .. }': E
+    277..278 'e': E
+    284..285 'd': &E
     "###
     );
 }
@@ -389,20 +389,20 @@ impl E {
 }
 "#),
         @r###"
-    76..218 '{     ...     }': ()
-    86..211 'match ...     }': ()
-    93..100 'loop {}': !
-    98..100 '{}': ()
-    116..129 'Self::A { x }': E
-    126..127 'x': usize
-    133..139 '{ x; }': ()
-    135..136 'x': usize
-    153..163 'Self::B(x)': E
-    161..162 'x': usize
-    167..173 '{ x; }': ()
-    169..170 'x': usize
-    187..194 'Self::C': E
-    198..200 '{}': ()
+    75..217 '{     ...     }': ()
+    85..210 'match ...     }': ()
+    92..99 'loop {}': !
+    97..99 '{}': ()
+    115..128 'Self::A { x }': E
+    125..126 'x': usize
+    132..138 '{ x; }': ()
+    134..135 'x': usize
+    152..162 'Self::B(x)': E
+    160..161 'x': usize
+    166..172 '{ x; }': ()
+    168..169 'x': usize
+    186..193 'Self::C': E
+    197..199 '{}': ()
     "###
     );
 }
@@ -430,23 +430,23 @@ fn test(a1: A<u32>, o: Option<u64>) {
 }
 "#),
         @r###"
-    79..81 'a1': A<u32>
-    91..92 'o': Option<u64>
-    107..244 '{     ...  }; }': ()
-    117..128 'A { x: x2 }': A<u32>
-    124..126 'x2': u32
-    131..133 'a1': A<u32>
-    143..161 'A::<i6...: x3 }': A<i64>
-    157..159 'x3': i64
-    164..174 'A { x: 1 }': A<i64>
-    171..172 '1': i64
-    180..241 'match ...     }': u64
-    186..187 'o': Option<u64>
-    198..213 'Option::Some(t)': Option<u64>
-    211..212 't': u64
-    217..218 't': u64
-    228..229 '_': Option<u64>
-    233..234 '1': u64
+    78..80 'a1': A<u32>
+    90..91 'o': Option<u64>
+    106..243 '{     ...  }; }': ()
+    116..127 'A { x: x2 }': A<u32>
+    123..125 'x2': u32
+    130..132 'a1': A<u32>
+    142..160 'A::<i6...: x3 }': A<i64>
+    156..158 'x3': i64
+    163..173 'A { x: 1 }': A<i64>
+    170..171 '1': i64
+    179..240 'match ...     }': u64
+    185..186 'o': Option<u64>
+    197..212 'Option::Some(t)': Option<u64>
+    210..211 't': u64
+    216..217 't': u64
+    227..228 '_': Option<u64>
+    232..233 '1': u64
     "###
     );
 }
@@ -470,27 +470,27 @@ fn test() {
 }
 "#, true),
         @r###"
-    74..75 '1': usize
-    88..310 '{     ...atch }': ()
-    98..99 'a': Option<u32>
-    115..119 'None': Option<u32>
-    129..130 'b': Option<i64>
-    146..183 'match ...     }': Option<i64>
-    152..153 'a': Option<u32>
-    164..168 'None': Option<u32>
-    172..176 'None': Option<i64>
-    193..194 '_': ()
-    201..224 'match ... Foo }': Foo
-    207..209 '()': ()
-    212..215 'Foo': Foo
-    219..222 'Foo': Foo
-    255..256 '_': ()
-    263..286 'match ... Bar }': usize
-    269..271 '()': ()
-    274..277 'Bar': usize
-    281..284 'Bar': usize
-    201..224: expected (), got Foo
-    263..286: expected (), got usize
+    73..74 '1': usize
+    87..309 '{     ...atch }': ()
+    97..98 'a': Option<u32>
+    114..118 'None': Option<u32>
+    128..129 'b': Option<i64>
+    145..182 'match ...     }': Option<i64>
+    151..152 'a': Option<u32>
+    163..167 'None': Option<u32>
+    171..175 'None': Option<i64>
+    192..193 '_': ()
+    200..223 'match ... Foo }': Foo
+    206..208 '()': ()
+    211..214 'Foo': Foo
+    218..221 'Foo': Foo
+    254..255 '_': ()
+    262..285 'match ... Bar }': usize
+    268..270 '()': ()
+    273..276 'Bar': usize
+    280..283 'Bar': usize
+    200..223: expected (), got Foo
+    262..285: expected (), got usize
     "###
     );
 }
@@ -507,18 +507,18 @@ fn main() {
         s if s.foo() => (),
     }
 }
-    "#), @"
-        28..32 'self': &S
-        42..51 '{ false }': bool
-        44..49 'false': bool
-        65..116 '{     ...   } }': ()
-        71..114 'match ...     }': ()
-        77..78 'S': S
-        89..90 's': S
-        94..95 's': S
-        94..101 's.foo()': bool
-        105..107 '()': ()
-    ")
+    "#), @r###"
+    27..31 'self': &S
+    41..50 '{ false }': bool
+    43..48 'false': bool
+    64..115 '{     ...   } }': ()
+    70..113 'match ...     }': ()
+    76..77 'S': S
+    88..89 's': S
+    93..94 's': S
+    93..100 's.foo()': bool
+    104..106 '()': ()
+    "###)
 }
 
 #[test]
@@ -538,35 +538,35 @@ fn test() {
 }
 "#),
         @r###"
-    94..95 't': T
-    100..101 'f': F
-    111..122 '{ loop {} }': U
-    113..120 'loop {}': !
-    118..120 '{}': ()
-    134..233 '{     ... x); }': ()
-    140..143 'foo': fn foo<&(i32, &str), i32, |&(i32, &str)| -> i32>(&(i32, &str), |&(i32, &str)| -> i32) -> i32
-    140..167 'foo(&(...y)| x)': i32
-    144..153 '&(1, "a")': &(i32, &str)
-    145..153 '(1, "a")': (i32, &str)
-    146..147 '1': i32
-    149..152 '"a"': &str
-    155..166 '|&(x, y)| x': |&(i32, &str)| -> i32
-    156..163 '&(x, y)': &(i32, &str)
-    157..163 '(x, y)': (i32, &str)
-    158..159 'x': i32
-    161..162 'y': &str
-    165..166 'x': i32
-    204..207 'foo': fn foo<&(i32, &str), &i32, |&(i32, &str)| -> &i32>(&(i32, &str), |&(i32, &str)| -> &i32) -> &i32
-    204..230 'foo(&(...y)| x)': &i32
-    208..217 '&(1, "a")': &(i32, &str)
-    209..217 '(1, "a")': (i32, &str)
-    210..211 '1': i32
-    213..216 '"a"': &str
-    219..229 '|(x, y)| x': |&(i32, &str)| -> &i32
-    220..226 '(x, y)': (i32, &str)
-    221..222 'x': &i32
-    224..225 'y': &&str
-    228..229 'x': &i32
+    93..94 't': T
+    99..100 'f': F
+    110..121 '{ loop {} }': U
+    112..119 'loop {}': !
+    117..119 '{}': ()
+    133..232 '{     ... x); }': ()
+    139..142 'foo': fn foo<&(i32, &str), i32, |&(i32, &str)| -> i32>(&(i32, &str), |&(i32, &str)| -> i32) -> i32
+    139..166 'foo(&(...y)| x)': i32
+    143..152 '&(1, "a")': &(i32, &str)
+    144..152 '(1, "a")': (i32, &str)
+    145..146 '1': i32
+    148..151 '"a"': &str
+    154..165 '|&(x, y)| x': |&(i32, &str)| -> i32
+    155..162 '&(x, y)': &(i32, &str)
+    156..162 '(x, y)': (i32, &str)
+    157..158 'x': i32
+    160..161 'y': &str
+    164..165 'x': i32
+    203..206 'foo': fn foo<&(i32, &str), &i32, |&(i32, &str)| -> &i32>(&(i32, &str), |&(i32, &str)| -> &i32) -> &i32
+    203..229 'foo(&(...y)| x)': &i32
+    207..216 '&(1, "a")': &(i32, &str)
+    208..216 '(1, "a")': (i32, &str)
+    209..210 '1': i32
+    212..215 '"a"': &str
+    218..228 '|(x, y)| x': |&(i32, &str)| -> &i32
+    219..225 '(x, y)': (i32, &str)
+    220..221 'x': &i32
+    223..224 'y': &&str
+    227..228 'x': &i32
     "###
     );
 }