Fix substitution parts having a shifted underline in some cases

ShE3py · ShE3py · commit a580d10cf6f5 · 2024-04-27T00:43:28.000+02:00
diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
@@ -2019,7 +2019,7 @@ impl HumanEmitter {
                     let offset: isize = offsets
                         .iter()
                         .filter_map(
-                            |(start, v)| if span_start_pos <= *start { None } else { Some(v) },
+                            |(start, v)| if span_start_pos < *start { None } else { Some(v) },
                         )
                         .sum();
                     let underline_start = (span_start_pos + start) as isize + offset;
diff --git a/tests/ui/parser/issues/issue-24375.stderr b/tests/ui/parser/issues/issue-24375.stderr
@@ -7,7 +7,7 @@ LL |         tmp[0] => {}
 help: check the value in an arm guard
    |
 LL |         val if val == tmp[0] => {}
-   |         ~~~    ++++++++++++++++
+   |         ~~~ ++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = tmp[0];
diff --git a/tests/ui/parser/issues/issue-32505.stderr b/tests/ui/parser/issues/issue-32505.stderr
@@ -9,7 +9,7 @@ LL |     foo(|_|)
 help: you might have meant to open the body of the closure
    |
 LL |     foo(|_| {})
-   |            ++
+   |             ++
 
 error[E0425]: cannot find function `foo` in this scope
   --> $DIR/issue-32505.rs:2:5
diff --git a/tests/ui/parser/recover/recover-pat-exprs.stderr b/tests/ui/parser/recover/recover-pat-exprs.stderr
@@ -58,7 +58,7 @@ LL |         x._0 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x._0 => (),
-   |         ~~~  ++++++++++++++
+   |         ~~~ ++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x._0;
@@ -82,7 +82,7 @@ LL |         x.0.1 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x.0.1 => (),
-   |         ~~~   +++++++++++++++
+   |         ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x.0.1;
@@ -106,7 +106,7 @@ LL |         x.4.y.17.__z => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x.4.y.17.__z => (),
-   |         ~~~          ++++++++++++++++++++++
+   |         ~~~ ++++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x.4.y.17.__z;
@@ -130,7 +130,7 @@ LL |         x.f() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x.f() => (),
-   |         ~~~   +++++++++++++++
+   |         ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x.f();
@@ -151,7 +151,7 @@ LL |         x._f() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x._f() => (),
-   |         ~~~    ++++++++++++++++
+   |         ~~~ ++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x._f();
@@ -173,7 +173,7 @@ LL |         x? => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x? => (),
-   |         ~~~++++++++++++
+   |         ~~~ ++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x?;
@@ -196,7 +196,7 @@ LL |         ().f() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == ().f() => (),
-   |         ~~~    ++++++++++++++++
+   |         ~~~ ++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = ().f();
@@ -220,7 +220,7 @@ LL |         (0, x)?.f() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == (0, x)?.f() => (),
-   |         ~~~         +++++++++++++++++++++
+   |         ~~~ +++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = (0, x)?.f();
@@ -244,7 +244,7 @@ LL |         x.f().g() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x.f().g() => (),
-   |         ~~~       +++++++++++++++++++
+   |         ~~~ +++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x.f().g();
@@ -268,7 +268,7 @@ LL |         0.f()?.g()?? => (),
 help: check the value in an arm guard
    |
 LL |         val if val == 0.f()?.g()?? => (),
-   |         ~~~          ++++++++++++++++++++++
+   |         ~~~ ++++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = 0.f()?.g()??;
@@ -292,7 +292,7 @@ LL |         x as usize => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x as usize => (),
-   |         ~~~        ++++++++++++++++++++
+   |         ~~~ ++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x as usize;
@@ -313,7 +313,7 @@ LL |         0 as usize => (),
 help: check the value in an arm guard
    |
 LL |         val if val == 0 as usize => (),
-   |         ~~~        ++++++++++++++++++++
+   |         ~~~ ++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = 0 as usize;
@@ -335,7 +335,7 @@ LL |         x.f().0.4 as f32 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == x.f().0.4 as f32 => (),
-   |         ~~~              ++++++++++++++++++++++++++
+   |         ~~~ ++++++++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = x.f().0.4 as f32;
@@ -358,7 +358,7 @@ LL |         1 + 1 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == 1 + 1 => (),
-   |         ~~~   +++++++++++++++
+   |         ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = 1 + 1;
@@ -379,7 +379,7 @@ LL |         (1 + 2) * 3 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == (1 + 2) * 3 => (),
-   |         ~~~         +++++++++++++++++++++
+   |         ~~~ +++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = (1 + 2) * 3;
@@ -418,7 +418,7 @@ LL |         u8::MAX.abs() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == u8::MAX.abs() => (),
-   |         ~~~           +++++++++++++++++++++++
+   |         ~~~ +++++++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = u8::MAX.abs();
@@ -439,7 +439,7 @@ LL |         z @ w @ v.u() => (),
 help: check the value in an arm guard
    |
 LL |         z @ w @ val if val == v.u() => (),
-   |                 ~~~   +++++++++++++++
+   |                 ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = v.u();
@@ -463,7 +463,7 @@ LL |         y.ilog(3) => (),
 help: check the value in an arm guard
    |
 LL |         val if val == y.ilog(3) => (),
-   |         ~~~       +++++++++++++++++++
+   |         ~~~ +++++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = y.ilog(3);
@@ -487,7 +487,7 @@ LL |         n + 1 => (),
 help: check the value in an arm guard
    |
 LL |         val if val == n + 1 => (),
-   |         ~~~   +++++++++++++++
+   |         ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = n + 1;
@@ -535,7 +535,7 @@ LL |         f?() => (),
 help: check the value in an arm guard
    |
 LL |         val if val == f?() => (),
-   |         ~~~  ++++++++++++++
+   |         ~~~ ++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = f?();
diff --git a/tests/ui/parser/recover/recover-pat-ranges.stderr b/tests/ui/parser/recover/recover-pat-ranges.stderr
@@ -91,7 +91,7 @@ LL |         ..=1 + 2 => (),
 help: check the value in an arm guard
    |
 LL |         ..=val if val == 1 + 2 => (),
-   |            ~~~   +++++++++++++++
+   |            ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = 1 + 2;
@@ -163,7 +163,7 @@ LL |         (1 + 4)...1 * 2 => (),
 help: check the value in an arm guard
    |
 LL |         (1 + 4)...val if val == 1 * 2 => (),
-   |                   ~~~   +++++++++++++++
+   |                   ~~~ +++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = 1 * 2;
@@ -211,7 +211,7 @@ LL |         0.x()..="y".z() => (),
 help: check the value in an arm guard
    |
 LL |         0.x()..=val if val == "y".z() => (),
-   |                 ~~~     +++++++++++++++++
+   |                 ~~~ +++++++++++++++++
 help: extract the expression into a `const` and refer to it
    |
 LL +     const VAL: _ = "y".z();

Original file line number	Diff line number	Diff line change
`@@ -2019,7 +2019,7 @@ impl HumanEmitter {`
`2019`	`2019`	`let offset: isize = offsets`
`2020`	`2020`	`.iter()`
`2021`	`2021`	`.filter_map(`
`2022`		`- \|(start, v)\| if span_start_pos <= *start { None } else { Some(v) },`
	`2022`	`+ \|(start, v)\| if span_start_pos < *start { None } else { Some(v) },`
`2023`	`2023`	`)`
`2024`	`2024`	`.sum();`
`2025`	`2025`	`let underline_start = (span_start_pos + start) as isize + offset;`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ LL \| tmp[0] => {}`
`7`	`7`	`help: check the value in an arm guard`
`8`	`8`	`\|`
`9`	`9`	`LL \| val if val == tmp[0] => {}`
`10`		`- \| ~~~ ++++++++++++++++`
	`10`	`+ \| ~~~ ++++++++++++++++`
`11`	`11`	help: extract the expression into a `const` and refer to it
`12`	`12`	`\|`
`13`	`13`	`LL + const VAL: _ = tmp[0];`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ LL \| foo(\|_\|)`
`9`	`9`	`help: you might have meant to open the body of the closure`
`10`	`10`	`\|`
`11`	`11`	`LL \| foo(\|_\| {})`
`12`		`- \| ++`
	`12`	`+ \| ++`
`13`	`13`
`14`	`14`	error[E0425]: cannot find function `foo` in this scope
`15`	`15`	`--> $DIR/issue-32505.rs:2:5`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ LL \| x._0 => (),`
`58`	`58`	`help: check the value in an arm guard`
`59`	`59`	`\|`
`60`	`60`	`LL \| val if val == x._0 => (),`
`61`		`- \| ~~~ ++++++++++++++`
	`61`	`+ \| ~~~ ++++++++++++++`
`62`	`62`	help: extract the expression into a `const` and refer to it
`63`	`63`	`\|`
`64`	`64`	`LL + const VAL: _ = x._0;`
`@@ -82,7 +82,7 @@ LL \| x.0.1 => (),`
`82`	`82`	`help: check the value in an arm guard`
`83`	`83`	`\|`
`84`	`84`	`LL \| val if val == x.0.1 => (),`
`85`		`- \| ~~~ +++++++++++++++`
	`85`	`+ \| ~~~ +++++++++++++++`
`86`	`86`	help: extract the expression into a `const` and refer to it
`87`	`87`	`\|`
`88`	`88`	`LL + const VAL: _ = x.0.1;`
`@@ -106,7 +106,7 @@ LL \| x.4.y.17.__z => (),`
`106`	`106`	`help: check the value in an arm guard`
`107`	`107`	`\|`
`108`	`108`	`LL \| val if val == x.4.y.17.__z => (),`
`109`		`- \| ~~~ ++++++++++++++++++++++`
	`109`	`+ \| ~~~ ++++++++++++++++++++++`
`110`	`110`	help: extract the expression into a `const` and refer to it
`111`	`111`	`\|`
`112`	`112`	`LL + const VAL: _ = x.4.y.17.__z;`
`@@ -130,7 +130,7 @@ LL \| x.f() => (),`
`130`	`130`	`help: check the value in an arm guard`
`131`	`131`	`\|`
`132`	`132`	`LL \| val if val == x.f() => (),`
`133`		`- \| ~~~ +++++++++++++++`
	`133`	`+ \| ~~~ +++++++++++++++`
`134`	`134`	help: extract the expression into a `const` and refer to it
`135`	`135`	`\|`
`136`	`136`	`LL + const VAL: _ = x.f();`
`@@ -151,7 +151,7 @@ LL \| x._f() => (),`
`151`	`151`	`help: check the value in an arm guard`
`152`	`152`	`\|`
`153`	`153`	`LL \| val if val == x._f() => (),`
`154`		`- \| ~~~ ++++++++++++++++`
	`154`	`+ \| ~~~ ++++++++++++++++`
`155`	`155`	help: extract the expression into a `const` and refer to it
`156`	`156`	`\|`
`157`	`157`	`LL + const VAL: _ = x._f();`
`@@ -173,7 +173,7 @@ LL \| x? => (),`
`173`	`173`	`help: check the value in an arm guard`
`174`	`174`	`\|`
`175`	`175`	`LL \| val if val == x? => (),`
`176`		`- \| ~~~++++++++++++`
	`176`	`+ \| ~~~ ++++++++++++`
`177`	`177`	help: extract the expression into a `const` and refer to it
`178`	`178`	`\|`
`179`	`179`	`LL + const VAL: _ = x?;`
`@@ -196,7 +196,7 @@ LL \| ().f() => (),`
`196`	`196`	`help: check the value in an arm guard`
`197`	`197`	`\|`
`198`	`198`	`LL \| val if val == ().f() => (),`
`199`		`- \| ~~~ ++++++++++++++++`
	`199`	`+ \| ~~~ ++++++++++++++++`
`200`	`200`	help: extract the expression into a `const` and refer to it
`201`	`201`	`\|`
`202`	`202`	`LL + const VAL: _ = ().f();`
`@@ -220,7 +220,7 @@ LL \| (0, x)?.f() => (),`
`220`	`220`	`help: check the value in an arm guard`
`221`	`221`	`\|`
`222`	`222`	`LL \| val if val == (0, x)?.f() => (),`
`223`		`- \| ~~~ +++++++++++++++++++++`
	`223`	`+ \| ~~~ +++++++++++++++++++++`
`224`	`224`	help: extract the expression into a `const` and refer to it
`225`	`225`	`\|`
`226`	`226`	`LL + const VAL: _ = (0, x)?.f();`
`@@ -244,7 +244,7 @@ LL \| x.f().g() => (),`
`244`	`244`	`help: check the value in an arm guard`
`245`	`245`	`\|`
`246`	`246`	`LL \| val if val == x.f().g() => (),`
`247`		`- \| ~~~ +++++++++++++++++++`
	`247`	`+ \| ~~~ +++++++++++++++++++`
`248`	`248`	help: extract the expression into a `const` and refer to it
`249`	`249`	`\|`
`250`	`250`	`LL + const VAL: _ = x.f().g();`
`@@ -268,7 +268,7 @@ LL \| 0.f()?.g()?? => (),`
`268`	`268`	`help: check the value in an arm guard`
`269`	`269`	`\|`
`270`	`270`	`LL \| val if val == 0.f()?.g()?? => (),`
`271`		`- \| ~~~ ++++++++++++++++++++++`
	`271`	`+ \| ~~~ ++++++++++++++++++++++`
`272`	`272`	help: extract the expression into a `const` and refer to it
`273`	`273`	`\|`
`274`	`274`	`LL + const VAL: _ = 0.f()?.g()??;`
`@@ -292,7 +292,7 @@ LL \| x as usize => (),`
`292`	`292`	`help: check the value in an arm guard`
`293`	`293`	`\|`
`294`	`294`	`LL \| val if val == x as usize => (),`
`295`		`- \| ~~~ ++++++++++++++++++++`
	`295`	`+ \| ~~~ ++++++++++++++++++++`
`296`	`296`	help: extract the expression into a `const` and refer to it
`297`	`297`	`\|`
`298`	`298`	`LL + const VAL: _ = x as usize;`
`@@ -313,7 +313,7 @@ LL \| 0 as usize => (),`
`313`	`313`	`help: check the value in an arm guard`
`314`	`314`	`\|`
`315`	`315`	`LL \| val if val == 0 as usize => (),`
`316`		`- \| ~~~ ++++++++++++++++++++`
	`316`	`+ \| ~~~ ++++++++++++++++++++`
`317`	`317`	help: extract the expression into a `const` and refer to it
`318`	`318`	`\|`
`319`	`319`	`LL + const VAL: _ = 0 as usize;`
`@@ -335,7 +335,7 @@ LL \| x.f().0.4 as f32 => (),`
`335`	`335`	`help: check the value in an arm guard`
`336`	`336`	`\|`
`337`	`337`	`LL \| val if val == x.f().0.4 as f32 => (),`
`338`		`- \| ~~~ ++++++++++++++++++++++++++`
	`338`	`+ \| ~~~ ++++++++++++++++++++++++++`
`339`	`339`	help: extract the expression into a `const` and refer to it
`340`	`340`	`\|`
`341`	`341`	`LL + const VAL: _ = x.f().0.4 as f32;`
`@@ -358,7 +358,7 @@ LL \| 1 + 1 => (),`
`358`	`358`	`help: check the value in an arm guard`
`359`	`359`	`\|`
`360`	`360`	`LL \| val if val == 1 + 1 => (),`
`361`		`- \| ~~~ +++++++++++++++`
	`361`	`+ \| ~~~ +++++++++++++++`
`362`	`362`	help: extract the expression into a `const` and refer to it
`363`	`363`	`\|`
`364`	`364`	`LL + const VAL: _ = 1 + 1;`
`@@ -379,7 +379,7 @@ LL \| (1 + 2) * 3 => (),`
`379`	`379`	`help: check the value in an arm guard`
`380`	`380`	`\|`
`381`	`381`	`LL \| val if val == (1 + 2) * 3 => (),`
`382`		`- \| ~~~ +++++++++++++++++++++`
	`382`	`+ \| ~~~ +++++++++++++++++++++`
`383`	`383`	help: extract the expression into a `const` and refer to it
`384`	`384`	`\|`
`385`	`385`	`LL + const VAL: _ = (1 + 2) * 3;`
`@@ -418,7 +418,7 @@ LL \| u8::MAX.abs() => (),`
`418`	`418`	`help: check the value in an arm guard`
`419`	`419`	`\|`
`420`	`420`	`LL \| val if val == u8::MAX.abs() => (),`
`421`		`- \| ~~~ +++++++++++++++++++++++`
	`421`	`+ \| ~~~ +++++++++++++++++++++++`
`422`	`422`	help: extract the expression into a `const` and refer to it
`423`	`423`	`\|`
`424`	`424`	`LL + const VAL: _ = u8::MAX.abs();`
`@@ -439,7 +439,7 @@ LL \| z @ w @ v.u() => (),`
`439`	`439`	`help: check the value in an arm guard`
`440`	`440`	`\|`
`441`	`441`	`LL \| z @ w @ val if val == v.u() => (),`
`442`		`- \| ~~~ +++++++++++++++`
	`442`	`+ \| ~~~ +++++++++++++++`
`443`	`443`	help: extract the expression into a `const` and refer to it
`444`	`444`	`\|`
`445`	`445`	`LL + const VAL: _ = v.u();`
`@@ -463,7 +463,7 @@ LL \| y.ilog(3) => (),`
`463`	`463`	`help: check the value in an arm guard`
`464`	`464`	`\|`
`465`	`465`	`LL \| val if val == y.ilog(3) => (),`
`466`		`- \| ~~~ +++++++++++++++++++`
	`466`	`+ \| ~~~ +++++++++++++++++++`
`467`	`467`	help: extract the expression into a `const` and refer to it
`468`	`468`	`\|`
`469`	`469`	`LL + const VAL: _ = y.ilog(3);`
`@@ -487,7 +487,7 @@ LL \| n + 1 => (),`
`487`	`487`	`help: check the value in an arm guard`
`488`	`488`	`\|`
`489`	`489`	`LL \| val if val == n + 1 => (),`
`490`		`- \| ~~~ +++++++++++++++`
	`490`	`+ \| ~~~ +++++++++++++++`
`491`	`491`	help: extract the expression into a `const` and refer to it
`492`	`492`	`\|`
`493`	`493`	`LL + const VAL: _ = n + 1;`
`@@ -535,7 +535,7 @@ LL \| f?() => (),`
`535`	`535`	`help: check the value in an arm guard`
`536`	`536`	`\|`
`537`	`537`	`LL \| val if val == f?() => (),`
`538`		`- \| ~~~ ++++++++++++++`
	`538`	`+ \| ~~~ ++++++++++++++`
`539`	`539`	help: extract the expression into a `const` and refer to it
`540`	`540`	`\|`
`541`	`541`	`LL + const VAL: _ = f?();`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ LL \| ..=1 + 2 => (),`
`91`	`91`	`help: check the value in an arm guard`
`92`	`92`	`\|`
`93`	`93`	`LL \| ..=val if val == 1 + 2 => (),`
`94`		`- \| ~~~ +++++++++++++++`
	`94`	`+ \| ~~~ +++++++++++++++`
`95`	`95`	help: extract the expression into a `const` and refer to it
`96`	`96`	`\|`
`97`	`97`	`LL + const VAL: _ = 1 + 2;`
`@@ -163,7 +163,7 @@ LL \| (1 + 4)...1 * 2 => (),`
`163`	`163`	`help: check the value in an arm guard`
`164`	`164`	`\|`
`165`	`165`	`LL \| (1 + 4)...val if val == 1 * 2 => (),`
`166`		`- \| ~~~ +++++++++++++++`
	`166`	`+ \| ~~~ +++++++++++++++`
`167`	`167`	help: extract the expression into a `const` and refer to it
`168`	`168`	`\|`
`169`	`169`	`LL + const VAL: _ = 1 * 2;`
`@@ -211,7 +211,7 @@ LL \| 0.x()..="y".z() => (),`
`211`	`211`	`help: check the value in an arm guard`
`212`	`212`	`\|`
`213`	`213`	`LL \| 0.x()..=val if val == "y".z() => (),`
`214`		`- \| ~~~ +++++++++++++++++`
	`214`	`+ \| ~~~ +++++++++++++++++`
`215`	`215`	help: extract the expression into a `const` and refer to it
`216`	`216`	`\|`
`217`	`217`	`LL + const VAL: _ = "y".z();`