From fe3d3efdd1efe3275ce567386855c685688039fe Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 28 Oct 2025 15:50:45 -0600
Subject: [PATCH 1/4] test: Switch examples to use line numbers

---
 examples/highlight_message.rs  |  4 +---
 examples/highlight_message.svg |  8 ++++----
 examples/highlight_source.rs   |  4 +---
 examples/highlight_source.svg  | 14 +++++++-------
 4 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/examples/highlight_message.rs b/examples/highlight_message.rs
index d16152c5..a5f64475 100644
--- a/examples/highlight_message.rs
+++ b/examples/highlight_message.rs
@@ -62,8 +62,6 @@ fn main() {
             ),
     ];
 
-    let renderer = Renderer::styled()
-        .anonymized_line_numbers(true)
-        .decor_style(DecorStyle::Unicode);
+    let renderer = Renderer::styled().decor_style(DecorStyle::Unicode);
     anstream::println!("{}", renderer.render(report));
 }
diff --git a/examples/highlight_message.svg b/examples/highlight_message.svg
index 7d00563f..8f03b6b5 100644
--- a/examples/highlight_message.svg
+++ b/examples/highlight_message.svg
@@ -27,7 +27,7 @@
 </tspan>
     <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>     query(wrapped_fn);</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">21</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>     query(wrapped_fn);</tspan>
 </tspan>
     <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>     </tspan><tspan class="fg-bright-blue bold">┬────</tspan><tspan> </tspan><tspan class="fg-bright-red bold">━━━━━━━━━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">one type is more general than the other</tspan>
 </tspan>
@@ -47,13 +47,13 @@
 </tspan>
     <tspan x="10px" y="244px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="262px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>   fn query(_: fn(Box&lt;(dyn Any + Send + '_)&gt;) -&gt; Pin&lt;Box&lt;(</tspan>
+    <tspan x="10px" y="262px"><tspan class="fg-bright-blue bold">10</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>   fn query(_: fn(Box&lt;(dyn Any + Send + '_)&gt;) -&gt; Pin&lt;Box&lt;(</tspan>
 </tspan>
     <tspan x="10px" y="280px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">┌────</tspan><tspan class="fg-bright-green bold">━━━━━</tspan><tspan class="fg-bright-blue bold">─┘</tspan>
 </tspan>
-    <tspan x="10px" y="298px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>     dyn Future&lt;Output = Result&lt;Box&lt;(dyn Any + 'static)&gt;, String&gt;&gt; + Send + 'static</tspan>
+    <tspan x="10px" y="298px"><tspan class="fg-bright-blue bold">11</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>     dyn Future&lt;Output = Result&lt;Box&lt;(dyn Any + 'static)&gt;, String&gt;&gt; + Send + 'static</tspan>
 </tspan>
-    <tspan x="10px" y="316px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> )&gt;&gt;) {}</tspan>
+    <tspan x="10px" y="316px"><tspan class="fg-bright-blue bold">12</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> )&gt;&gt;) {}</tspan>
 </tspan>
     <tspan x="10px" y="334px"><tspan>   </tspan><tspan class="fg-bright-blue bold">╰╴└───┘</tspan>
 </tspan>
diff --git a/examples/highlight_source.rs b/examples/highlight_source.rs
index 7af3d701..c62dbba0 100644
--- a/examples/highlight_source.rs
+++ b/examples/highlight_source.rs
@@ -26,8 +26,6 @@ fn main() {}
 
     )];
 
-    let renderer = Renderer::styled()
-        .anonymized_line_numbers(true)
-        .decor_style(DecorStyle::Unicode);
+    let renderer = Renderer::styled().decor_style(DecorStyle::Unicode);
     anstream::println!("{}", renderer.render(report));
 }
diff --git a/examples/highlight_source.svg b/examples/highlight_source.svg
index 0d360253..b6421760 100644
--- a/examples/highlight_source.svg
+++ b/examples/highlight_source.svg
@@ -1,4 +1,4 @@
-<svg width="961px" height="164px" xmlns="http://www.w3.org/2000/svg">
+<svg width="953px" height="164px" xmlns="http://www.w3.org/2000/svg">
   <style>
     .fg { fill: #AAAAAA }
     .bg { background: #000000 }
@@ -21,17 +21,17 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0010]</tspan><tspan class="bold">: allocations are not allowed in constants</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/E0010-teach.rs:5:23</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/E0010-teach.rs:5:23</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> const CON: Vec&lt;i32&gt; = </tspan><tspan class="fg-bright-red bold">vec![1, 2, 3]</tspan><tspan>; //~ ERROR E0010</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">5</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> const CON: Vec&lt;i32&gt; = </tspan><tspan class="fg-bright-red bold">vec![1, 2, 3]</tspan><tspan>; //~ ERROR E0010</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                       </tspan><tspan class="fg-bright-red bold">━━━━━━━━━━━━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">allocation not allowed in constants</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                       </tspan><tspan class="fg-bright-red bold">━━━━━━━━━━━━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">allocation not allowed in constants</tspan>
 </tspan>
-    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
+    <tspan x="10px" y="118px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-bright-blue bold">╰ </tspan><tspan class="bold">note</tspan><tspan>: The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created.</tspan>
+    <tspan x="10px" y="136px"><tspan>  </tspan><tspan class="fg-bright-blue bold">╰ </tspan><tspan class="bold">note</tspan><tspan>: The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created.</tspan>
 </tspan>
     <tspan x="10px" y="154px">
 </tspan>

From 4ddf6eeed091bf9f2c68c0cc942d2acc14c3c2de Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 28 Oct 2025 15:52:22 -0600
Subject: [PATCH 2/4] test: Switch color tests to use line numbers

---
 tests/color/strip_line.ascii.term.svg          |  8 ++++----
 tests/color/strip_line.rs                      |  2 +-
 tests/color/strip_line.unicode.term.svg        |  8 ++++----
 tests/color/strip_line_char.ascii.term.svg     |  8 ++++----
 tests/color/strip_line_char.rs                 |  2 +-
 tests/color/strip_line_char.unicode.term.svg   |  8 ++++----
 tests/color/strip_line_non_ws.ascii.term.svg   | 12 ++++++------
 tests/color/strip_line_non_ws.rs               |  2 +-
 tests/color/strip_line_non_ws.unicode.term.svg | 12 ++++++------
 9 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/tests/color/strip_line.ascii.term.svg b/tests/color/strip_line.ascii.term.svg
index 14fbf9dc..9f7b7ac3 100644
--- a/tests/color/strip_line.ascii.term.svg
+++ b/tests/color/strip_line.ascii.term.svg
@@ -21,13 +21,13 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan>                   let _: () = 42;</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan>                   let _: () = 42;</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
 </tspan>
   </text>
 
diff --git a/tests/color/strip_line.rs b/tests/color/strip_line.rs
index 4ad511e8..3de15f9d 100644
--- a/tests/color/strip_line.rs
+++ b/tests/color/strip_line.rs
@@ -21,7 +21,7 @@ fn case() {
         )];
 
     let expected_ascii = file!["strip_line.ascii.term.svg": TermSvg];
-    let renderer = Renderer::styled().anonymized_line_numbers(true);
+    let renderer = Renderer::styled();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = file!["strip_line.unicode.term.svg": TermSvg];
diff --git a/tests/color/strip_line.unicode.term.svg b/tests/color/strip_line.unicode.term.svg
index 2d536cf3..ed4493a1 100644
--- a/tests/color/strip_line.unicode.term.svg
+++ b/tests/color/strip_line.unicode.term.svg
@@ -21,13 +21,13 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan>                     let _: () = 42;</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan>                     let _: () = 42;</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                  </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                  </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
 </tspan>
   </text>
 
diff --git a/tests/color/strip_line_char.ascii.term.svg b/tests/color/strip_line_char.ascii.term.svg
index b37d4a9a..ec166692 100644
--- a/tests/color/strip_line_char.ascii.term.svg
+++ b/tests/color/strip_line_char.ascii.term.svg
@@ -21,13 +21,13 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan>                   let _: () = 42ñ</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan>                   let _: () = 42ñ</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
 </tspan>
   </text>
 
diff --git a/tests/color/strip_line_char.rs b/tests/color/strip_line_char.rs
index f0324ac1..a13a391e 100644
--- a/tests/color/strip_line_char.rs
+++ b/tests/color/strip_line_char.rs
@@ -21,7 +21,7 @@ fn case() {
         )];
 
     let expected_ascii = file!["strip_line_char.ascii.term.svg": TermSvg];
-    let renderer = Renderer::styled().anonymized_line_numbers(true);
+    let renderer = Renderer::styled();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = file!["strip_line_char.unicode.term.svg": TermSvg];
diff --git a/tests/color/strip_line_char.unicode.term.svg b/tests/color/strip_line_char.unicode.term.svg
index 3519f037..ba16ad6f 100644
--- a/tests/color/strip_line_char.unicode.term.svg
+++ b/tests/color/strip_line_char.unicode.term.svg
@@ -21,13 +21,13 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/whitespace-trimming.rs:4:193</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan>                     let _: () = 42ñ</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan>                     let _: () = 42ñ</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                  </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                  </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected (), found integer</tspan>
 </tspan>
   </text>
 
diff --git a/tests/color/strip_line_non_ws.ascii.term.svg b/tests/color/strip_line_non_ws.ascii.term.svg
index 6f799d35..06c3d548 100644
--- a/tests/color/strip_line_non_ws.ascii.term.svg
+++ b/tests/color/strip_line_non_ws.ascii.term.svg
@@ -21,17 +21,17 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/non-whitespace-trimming.rs:4:233</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold">--&gt; </tspan><tspan>$DIR/non-whitespace-trimming.rs:4:233</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan> = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = (); let _: () = (); let _: () = (); let _: () = (); let _: () </tspan><tspan class="fg-bright-blue bold">...</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">...</tspan><tspan>) = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = (); let _: () = (); let _: () = (); let _: () = (); let _: () </tspan><tspan class="fg-bright-blue bold">...</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan>   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected `()`, found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan>   </tspan><tspan class="fg-bright-red bold">^^</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected `()`, found integer</tspan>
 </tspan>
-    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">|</tspan>
+    <tspan x="10px" y="118px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                   </tspan><tspan class="fg-bright-red bold">|</tspan>
 </tspan>
-    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">expected due to this</tspan>
+    <tspan x="10px" y="136px"><tspan>  </tspan><tspan class="fg-bright-blue bold">|</tspan><tspan>                                                   </tspan><tspan class="fg-bright-red bold">expected due to this</tspan>
 </tspan>
   </text>
 
diff --git a/tests/color/strip_line_non_ws.rs b/tests/color/strip_line_non_ws.rs
index fb42bc08..f4c82051 100644
--- a/tests/color/strip_line_non_ws.rs
+++ b/tests/color/strip_line_non_ws.rs
@@ -27,7 +27,7 @@ fn case() {
         )];
 
     let expected_ascii = file!["strip_line_non_ws.ascii.term.svg": TermSvg];
-    let renderer = Renderer::styled().anonymized_line_numbers(true);
+    let renderer = Renderer::styled();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = file!["strip_line_non_ws.unicode.term.svg": TermSvg];
diff --git a/tests/color/strip_line_non_ws.unicode.term.svg b/tests/color/strip_line_non_ws.unicode.term.svg
index 977c6519..bc928282 100644
--- a/tests/color/strip_line_non_ws.unicode.term.svg
+++ b/tests/color/strip_line_non_ws.unicode.term.svg
@@ -21,17 +21,17 @@
   <text xml:space="preserve" class="container fg">
     <tspan x="10px" y="28px"><tspan class="fg-bright-red bold">error[E0308]</tspan><tspan class="bold">: mismatched types</tspan>
 </tspan>
-    <tspan x="10px" y="46px"><tspan>  </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/non-whitespace-trimming.rs:4:233</tspan>
+    <tspan x="10px" y="46px"><tspan> </tspan><tspan class="fg-bright-blue bold"> ╭▸ </tspan><tspan>$DIR/non-whitespace-trimming.rs:4:233</tspan>
 </tspan>
-    <tspan x="10px" y="64px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan>
+    <tspan x="10px" y="64px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">LL</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan>() = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = (); let _: () = (); let _: () = (); let _: () = (); let _: () = </tspan><tspan class="fg-bright-blue bold">…</tspan>
+    <tspan x="10px" y="82px"><tspan class="fg-bright-blue bold">4</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan> </tspan><tspan class="fg-bright-blue bold">…</tspan><tspan> () = (); let _: () = (); let _: () = (); let _: () = 42; let _: () = (); let _: () = (); let _: () = (); let _: () = (); let _: () = </tspan><tspan class="fg-bright-blue bold">…</tspan>
 </tspan>
-    <tspan x="10px" y="100px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">┯━</tspan><tspan>   </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected `()`, found integer</tspan>
+    <tspan x="10px" y="100px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                                                   </tspan><tspan class="fg-bright-red bold">┯━</tspan><tspan>   </tspan><tspan class="fg-bright-red bold">━━</tspan><tspan> </tspan><tspan class="fg-bright-red bold">expected `()`, found integer</tspan>
 </tspan>
-    <tspan x="10px" y="118px"><tspan>   </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">│</tspan>
+    <tspan x="10px" y="118px"><tspan>  </tspan><tspan class="fg-bright-blue bold">│</tspan><tspan>                                                   </tspan><tspan class="fg-bright-red bold">│</tspan>
 </tspan>
-    <tspan x="10px" y="136px"><tspan>   </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                                 </tspan><tspan class="fg-bright-red bold">expected due to this</tspan>
+    <tspan x="10px" y="136px"><tspan>  </tspan><tspan class="fg-bright-blue bold">╰╴</tspan><tspan>                                                  </tspan><tspan class="fg-bright-red bold">expected due to this</tspan>
 </tspan>
   </text>
 

From cc985090cd34a7f03e647dd45a7994d23e65c4c4 Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 28 Oct 2025 15:53:36 -0600
Subject: [PATCH 3/4] test: Switch formatter tests to use line numbers

---
 tests/formatter.rs | 746 ++++++++++++++++++++++-----------------------
 1 file changed, 370 insertions(+), 376 deletions(-)

diff --git a/tests/formatter.rs b/tests/formatter.rs
index 99a08636..f06d2e96 100644
--- a/tests/formatter.rs
+++ b/tests/formatter.rs
@@ -510,22 +510,22 @@ fn test_anon_lines() {
     let expected_ascii = str![[r#"
 error: 
    |
-LL | This is an example
-LL | of content lines
-LL |
-LL | abc
+56 | This is an example
+57 | of content lines
+58 |
+59 | abc
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: 
    ╭▸ 
-LL │ This is an example
-LL │ of content lines
-LL │
-LL │ abc
+56 │ This is an example
+57 │ of content lines
+58 │
+59 │ abc
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1591,34 +1591,34 @@ fn two_suggestions_same_span() {
 
     let expected_ascii = str![[r#"
 error[E0423]: expected value, found enum `A`
-   |
-LL |     A.foo();
-   |     ^
-   |
+  |
+1 |     A.foo();
+  |     ^
+  |
 help: you might have meant to use one of the following enum variants
-   |
-LL -     A.foo();
-LL +     (A::Tuple()).foo();
-   |
-LL |     A::Unit.foo();
-   |      ++++++
+  |
+1 -     A.foo();
+1 +     (A::Tuple()).foo();
+  |
+1 |     A::Unit.foo();
+  |      ++++++
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0423]: expected value, found enum `A`
-   ╭▸ 
-LL │     A.foo();
-   │     ━
-   ╰╴
+  ╭▸ 
+1 │     A.foo();
+  │     ━
+  ╰╴
 help: you might have meant to use one of the following enum variants
-   ╭╴
-LL -     A.foo();
-LL +     (A::Tuple()).foo();
-   ├╴
-LL │     A::Unit.foo();
-   ╰╴     ++++++
+  ╭╴
+1 -     A.foo();
+1 +     (A::Tuple()).foo();
+  ├╴
+1 │     A::Unit.foo();
+  ╰╴     ++++++
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1679,36 +1679,36 @@ fn main() {
     let expected_ascii = str![[r#"
 error[E0599]: no method named `pick` found for struct `Chaenomeles` in the current scope
    |
-LL |     pub struct Chaenomeles;
+ 3 |     pub struct Chaenomeles;
    |     ---------------------- method `pick` not found for this struct
 ...
-LL |     banana::Chaenomeles.pick()
+18 |     banana::Chaenomeles.pick()
    |                         ^^^^ method not found in `Chaenomeles`
    |
 help: the following traits which provide `pick` are implemented but not in scope; perhaps you want to import one of them
    |
-LL + use banana::Apple;
+ 2 + use banana::Apple;
    |
-LL + use banana::Peach;
+ 2 + use banana::Peach;
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0599]: no method named `pick` found for struct `Chaenomeles` in the current scope
    ╭▸ 
-LL │     pub struct Chaenomeles;
+ 3 │     pub struct Chaenomeles;
    │     ────────────────────── method `pick` not found for this struct
    ‡
-LL │     banana::Chaenomeles.pick()
+18 │     banana::Chaenomeles.pick()
    │                         ━━━━ method not found in `Chaenomeles`
    ╰╴
 help: the following traits which provide `pick` are implemented but not in scope; perhaps you want to import one of them
    ╭╴
-LL + use banana::Apple;
+ 2 + use banana::Apple;
    ├╴
-LL + use banana::Peach;
+ 2 + use banana::Peach;
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1739,30 +1739,30 @@ fn single_line_non_overlapping_suggestions() {
 
     let expected_ascii = str![[r#"
 error[E0423]: expected value, found enum `A`
-   |
-LL |     A.foo();
-   |     ^
-   |
+  |
+1 |     A.foo();
+  |     ^
+  |
 help: make these changes and things will work
-   |
-LL -     A.foo();
-LL +     (A::Tuple()).bar();
-   |
+  |
+1 -     A.foo();
+1 +     (A::Tuple()).bar();
+  |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0423]: expected value, found enum `A`
-   ╭▸ 
-LL │     A.foo();
-   │     ━
-   ╰╴
+  ╭▸ 
+1 │     A.foo();
+  │     ━
+  ╰╴
 help: make these changes and things will work
-   ╭╴
-LL -     A.foo();
-LL +     (A::Tuple()).bar();
-   ╰╴
+  ╭╴
+1 -     A.foo();
+1 +     (A::Tuple()).bar();
+  ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1791,30 +1791,30 @@ fn single_line_non_overlapping_suggestions2() {
 
     let expected_ascii = str![[r#"
 error[E0423]: Found `ThisIsVeryLong`
-   |
-LL |     ThisIsVeryLong.foo();
-   |     ^^^^^^^^^^^^^^
-   |
+  |
+1 |     ThisIsVeryLong.foo();
+  |     ^^^^^^^^^^^^^^
+  |
 help: make these changes and things will work
-   |
-LL -     ThisIsVeryLong.foo();
-LL +     (A::Tuple()).bar();
-   |
+  |
+1 -     ThisIsVeryLong.foo();
+1 +     (A::Tuple()).bar();
+  |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0423]: Found `ThisIsVeryLong`
-   ╭▸ 
-LL │     ThisIsVeryLong.foo();
-   │     ━━━━━━━━━━━━━━
-   ╰╴
+  ╭▸ 
+1 │     ThisIsVeryLong.foo();
+  │     ━━━━━━━━━━━━━━
+  ╰╴
 help: make these changes and things will work
-   ╭╴
-LL -     ThisIsVeryLong.foo();
-LL +     (A::Tuple()).bar();
-   ╰╴
+  ╭╴
+1 -     ThisIsVeryLong.foo();
+1 +     (A::Tuple()).bar();
+  ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1871,50 +1871,50 @@ fn multiple_replacements() {
     ];
     let expected_ascii = str![[r#"
 error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
-   |
-LL |     let y = || {
-   |             ^^ immutable borrow occurs here
-LL |         self.bar();
-   |         ^^^^ first borrow occurs due to use of `*self` in closure
-LL |     };
-LL |     self.qux();
-   |     ^^^^^^^^^^ mutable borrow occurs here
-LL |     y();
-   |     ^ immutable borrow later used here
-   |
+  |
+2 |     let y = || {
+  |             ^^ immutable borrow occurs here
+3 |         self.bar();
+  |         ^^^^ first borrow occurs due to use of `*self` in closure
+4 |     };
+5 |     self.qux();
+  |     ^^^^^^^^^^ mutable borrow occurs here
+6 |     y();
+  |     ^ immutable borrow later used here
+  |
 help: try explicitly pass `&Self` into the Closure as an argument
-   |
-LL ~     let y = |this: &Self| {
-LL ~         this.bar();
-LL |     };
-LL |     self.qux();
-LL ~     y(self);
-   |
+  |
+2 ~     let y = |this: &Self| {
+3 ~         this.bar();
+4 |     };
+5 |     self.qux();
+6 ~     y(self);
+  |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
-   ╭▸ 
-LL │     let y = || {
-   │             ━━ immutable borrow occurs here
-LL │         self.bar();
-   │         ━━━━ first borrow occurs due to use of `*self` in closure
-LL │     };
-LL │     self.qux();
-   │     ━━━━━━━━━━ mutable borrow occurs here
-LL │     y();
-   │     ━ immutable borrow later used here
-   ╰╴
+  ╭▸ 
+2 │     let y = || {
+  │             ━━ immutable borrow occurs here
+3 │         self.bar();
+  │         ━━━━ first borrow occurs due to use of `*self` in closure
+4 │     };
+5 │     self.qux();
+  │     ━━━━━━━━━━ mutable borrow occurs here
+6 │     y();
+  │     ━ immutable borrow later used here
+  ╰╴
 help: try explicitly pass `&Self` into the Closure as an argument
-   ╭╴
-LL ±     let y = |this: &Self| {
-LL ±         this.bar();
-LL │     };
-LL │     self.qux();
-LL ±     y(self);
-   ╰╴
+  ╭╴
+2 ±     let y = |this: &Self| {
+3 ±         this.bar();
+4 │     };
+5 │     self.qux();
+6 ±     y(self);
+  ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1973,42 +1973,42 @@ fn main() {
 
     let expected_ascii = str![[r#"
 error[E0499]: cannot borrow `chars` as mutable more than once at a time
-   |
-LL |     for _c in chars.by_ref() {
-   |               --------------
-   |               |
-   |               first mutable borrow occurs here
-   |               first borrow later used here
-LL |         chars.next();
-   |         ^^^^^ second mutable borrow occurs here
-   |
+  |
+4 |     for _c in chars.by_ref() {
+  |               --------------
+  |               |
+  |               first mutable borrow occurs here
+  |               first borrow later used here
+5 |         chars.next();
+  |         ^^^^^ second mutable borrow occurs here
+  |
 help: if you want to call `next` on a iterator within the loop, consider using `while let`
-   |
-LL ~     let iter = chars.by_ref();
-LL ~     while let Some(_c) = iter.next() {
-LL ~         iter.next();
-   |
+  |
+4 ~     let iter = chars.by_ref();
+5 ~     while let Some(_c) = iter.next() {
+6 ~         iter.next();
+  |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0499]: cannot borrow `chars` as mutable more than once at a time
-   ╭▸ 
-LL │     for _c in chars.by_ref() {
-   │               ┬─────────────
-   │               │
-   │               first mutable borrow occurs here
-   │               first borrow later used here
-LL │         chars.next();
-   │         ━━━━━ second mutable borrow occurs here
-   ╰╴
+  ╭▸ 
+4 │     for _c in chars.by_ref() {
+  │               ┬─────────────
+  │               │
+  │               first mutable borrow occurs here
+  │               first borrow later used here
+5 │         chars.next();
+  │         ━━━━━ second mutable borrow occurs here
+  ╰╴
 help: if you want to call `next` on a iterator within the loop, consider using `while let`
-   ╭╴
-LL ±     let iter = chars.by_ref();
-LL ±     while let Some(_c) = iter.next() {
-LL ±         iter.next();
-   ╰╴
+  ╭╴
+4 ±     let iter = chars.by_ref();
+5 ±     while let Some(_c) = iter.next() {
+6 ±         iter.next();
+  ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2057,45 +2057,45 @@ fn main() {}"#;
     let expected_ascii = str![[r#"
 error[E0433]: failed to resolve: use of undeclared crate or module `st`
    |
-LL |     bar: st::cell::Cell<bool>
+13 |     bar: st::cell::Cell<bool>
    |          ^^ use of undeclared crate or module `st`
    |
 help: there is a crate or module with a similar name
    |
-LL |     bar: std::cell::Cell<bool>
+13 |     bar: std::cell::Cell<bool>
    |            +
 help: consider importing this module
    |
-LL + use std::cell;
+ 2 + use std::cell;
    |
 help: if you import `cell`, refer to it directly
    |
-LL -     bar: st::cell::Cell<bool>
-LL +     bar: cell::Cell<bool>
+13 -     bar: st::cell::Cell<bool>
+13 +     bar: cell::Cell<bool>
    |
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0433]: failed to resolve: use of undeclared crate or module `st`
    ╭▸ 
-LL │     bar: st::cell::Cell<bool>
+13 │     bar: st::cell::Cell<bool>
    │          ━━ use of undeclared crate or module `st`
    ╰╴
 help: there is a crate or module with a similar name
    ╭╴
-LL │     bar: std::cell::Cell<bool>
+13 │     bar: std::cell::Cell<bool>
    ╰╴           +
 help: consider importing this module
    ╭╴
-LL + use std::cell;
+ 2 + use std::cell;
    ╰╴
 help: if you import `cell`, refer to it directly
    ╭╴
-LL -     bar: st::cell::Cell<bool>
-LL +     bar: cell::Cell<bool>
+13 -     bar: st::cell::Cell<bool>
+13 +     bar: cell::Cell<bool>
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2147,38 +2147,38 @@ fn main() {}"#;
     let expected_ascii = str![[r#"
 error[E0277]: the size for values of type `T` cannot be known at compilation time
    |
-LL | fn foo<T>(foo: Wrapper<T>)
+ 4 | fn foo<T>(foo: Wrapper<T>)
    |        -       ^^^^^^^^^^ doesn't have a size known at compile-time
    |        |
    |        this type parameter needs to be `Sized`
    |
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    |
-LL - where
-LL -     T
-LL -     :
-LL -     ?
-LL -     Sized
+ 6 - where
+ 7 -     T
+ 8 -     :
+ 9 -     ?
+10 -     Sized
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0277]: the size for values of type `T` cannot be known at compilation time
    ╭▸ 
-LL │ fn foo<T>(foo: Wrapper<T>)
+ 4 │ fn foo<T>(foo: Wrapper<T>)
    │        ┬       ━━━━━━━━━━ doesn't have a size known at compile-time
    │        │
    │        this type parameter needs to be `Sized`
    ╰╴
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    ╭╴
-LL - where
-LL -     T
-LL -     :
-LL -     ?
-LL -     Sized
+ 6 - where
+ 7 -     T
+ 8 -     :
+ 9 -     ?
+10 -     Sized
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2265,7 +2265,7 @@ fn main() {}"#;
 error[E0277]: the size for values of type `T` cannot be known at compilation time
   --> $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:4:16
    |
-LL | fn foo<T>(foo: Wrapper<T>)
+ 4 | fn foo<T>(foo: Wrapper<T>)
    |        -       ^^^^^^^^^^ doesn't have a size known at compile-time
    |        |
    |        this type parameter needs to be `Sized`
@@ -2273,33 +2273,33 @@ LL | fn foo<T>(foo: Wrapper<T>)
 note: required by an implicit `Sized` bound in `Wrapper`
   --> $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:2:16
    |
-LL | struct Wrapper<T>(T);
+ 2 | struct Wrapper<T>(T);
    |                ^ required by the implicit `Sized` requirement on this type parameter in `Wrapper`
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
   --> $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:2:16
    |
-LL | struct Wrapper<T>(T);
+ 2 | struct Wrapper<T>(T);
    |                ^  - ...if indirection were used here: `Box<T>`
    |                |
    |                this could be changed to `T: ?Sized`...
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    |
-LL - and where
-LL -     T
-LL -     :
-LL -     ?
-LL -     Sized
-LL + and + Send
+ 6 - and where
+ 7 -     T
+ 8 -     :
+ 9 -     ?
+10 -     Sized
+ 6 + and + Send
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0277]: the size for values of type `T` cannot be known at compilation time
    ╭▸ $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:4:16
    │
-LL │ fn foo<T>(foo: Wrapper<T>)
+ 4 │ fn foo<T>(foo: Wrapper<T>)
    │        ┬       ━━━━━━━━━━ doesn't have a size known at compile-time
    │        │
    │        this type parameter needs to be `Sized`
@@ -2307,23 +2307,23 @@ LL │ fn foo<T>(foo: Wrapper<T>)
 note: required by an implicit `Sized` bound in `Wrapper`
    ╭▸ $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:2:16
    │
-LL │ struct Wrapper<T>(T);
+ 2 │ struct Wrapper<T>(T);
    ╰╴               ━ required by the implicit `Sized` requirement on this type parameter in `Wrapper`
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
    ╭▸ $DIR/removal-of-multiline-trait-bound-in-where-clause.rs:2:16
    │
-LL │ struct Wrapper<T>(T);
+ 2 │ struct Wrapper<T>(T);
    │                ┯  ─ ...if indirection were used here: `Box<T>`
    │                │
    ╰╴               this could be changed to `T: ?Sized`...
 help: consider removing the `?Sized` bound to make the type parameter `Sized`
    ╭╴
-LL - and where
-LL -     T
-LL -     :
-LL -     ?
-LL -     Sized
-LL + and + Send
+ 6 - and where
+ 7 -     T
+ 8 -     :
+ 9 -     ?
+10 -     Sized
+ 6 + and + Send
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2459,42 +2459,40 @@ fn main() {
 error[E0271]: type mismatch resolving `<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ...>>, ...>>, ...> as Future>::Error == Foo`
   --> $DIR/E0271.rs:20:5
    |
-LL | /     Box::new(
-LL | |         Ok::<_, ()>(
-LL | |             Err::<(), _>(
-LL | |                 Ok::<_, ()>(
+20 | /     Box::new(
+21 | |         Ok::<_, ()>(
+22 | |             Err::<(), _>(
+23 | |                 Ok::<_, ()>(
 ...  |
-LL | |     )
+32 | |     )
    | |_____^ type mismatch resolving `<Result<Result<(), Result<Result<(), ...>, ...>>, ...> as Future>::Error == Foo`
    |
 note: expected this to be `Foo`
   --> $DIR/E0271.rs:10:18
    |
-LL |     type Error = E;
+10 |     type Error = E;
    |                  ^
    = note: required for the cast from `Box<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ()>>, ()>>, ()>>` to `Box<(dyn Future<Error = Foo> + 'static)>`
 "#]];
-    let renderer = Renderer::plain()
-        .term_width(40)
-        .anonymized_line_numbers(true);
+    let renderer = Renderer::plain().term_width(40);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0271]: type mismatch resolving `<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ...>>, ...>>, ...> as Future>::Error == Foo`
    ╭▸ $DIR/E0271.rs:20:5
    │
-LL │ ┏     Box::new(
-LL │ ┃         Ok::<_, ()>(
-LL │ ┃             Err::<(), _>(
-LL │ ┃                 Ok::<_, ()>(
+20 │ ┏     Box::new(
+21 │ ┃         Ok::<_, ()>(
+22 │ ┃             Err::<(), _>(
+23 │ ┃                 Ok::<_, ()>(
    ‡ ┃
-LL │ ┃     )
+32 │ ┃     )
    │ ┗━━━━━┛ type mismatch resolving `<Result<Result<(), Result<Result<(), ...>, ...>>, ...> as Future>::Error == Foo`
    ╰╴
 note: expected this to be `Foo`
    ╭▸ $DIR/E0271.rs:10:18
    │
-LL │     type Error = E;
+10 │     type Error = E;
    │                  ━
    ╰ note: required for the cast from `Box<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ()>>, ()>>, ()>>` to `Box<(dyn Future<Error = Foo> + 'static)>`
 "#]];
@@ -2571,43 +2569,41 @@ fn main() {
 error[E0271]: type mismatch resolving `<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ...>>, ...>>, ...> as Future>::Error == Foo`
   --> $DIR/E0271.rs:20:5
    |
-LL | /     Box::new(
-LL | |         Ok::<_, ()>(
-LL | |             Err::<(), _>(
-LL | |                 Ok::<_, ()>(
+20 | /     Box::new(
+21 | |         Ok::<_, ()>(
+22 | |             Err::<(), _>(
+23 | |                 Ok::<_, ()>(
 ...  |
-LL | |     )
+32 | |     )
    | |_____^ type mismatch resolving `<Result<Result<(), Result<Result<(), ...>, ...>>, ...> as Future>::Error == Foo`
    |
 note: expected this to be `Foo`
   --> $DIR/E0271.rs:10:18
    |
-LL |     type Error = E;
+10 |     type Error = E;
    |                  ^
    = note: required for the cast from `Box<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ()>>, ()>>, ()>>` to `Box<(dyn Future<Error = Foo> + 'static)>`
    = note: a second note
 "#]];
-    let renderer = Renderer::plain()
-        .term_width(40)
-        .anonymized_line_numbers(true);
+    let renderer = Renderer::plain().term_width(40);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0271]: type mismatch resolving `<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ...>>, ...>>, ...> as Future>::Error == Foo`
    ╭▸ $DIR/E0271.rs:20:5
    │
-LL │ ┏     Box::new(
-LL │ ┃         Ok::<_, ()>(
-LL │ ┃             Err::<(), _>(
-LL │ ┃                 Ok::<_, ()>(
+20 │ ┏     Box::new(
+21 │ ┃         Ok::<_, ()>(
+22 │ ┃             Err::<(), _>(
+23 │ ┃                 Ok::<_, ()>(
    ‡ ┃
-LL │ ┃     )
+32 │ ┃     )
    │ ┗━━━━━┛ type mismatch resolving `<Result<Result<(), Result<Result<(), ...>, ...>>, ...> as Future>::Error == Foo`
    ╰╴
 note: expected this to be `Foo`
    ╭▸ $DIR/E0271.rs:10:18
    │
-LL │     type Error = E;
+10 │     type Error = E;
    │                  ━
    ├ note: required for the cast from `Box<Result<Result<(), Result<Result<(), Result<Result<(), Option<{integer}>>, ()>>, ()>>, ()>>` to `Box<(dyn Future<Error = Foo> + 'static)>`
    ╰ note: a second note
@@ -2749,21 +2745,21 @@ fn main() {
 error[E0308]: mismatched types
   --> $DIR/long-E0308.rs:48:9
    |
-LL |        let x: Atype<
+24 |        let x: Atype<
    |  _____________-
-LL | |        Btype<
-LL | |          Ctype<
-LL | |            Atype<
+25 | |        Btype<
+26 | |          Ctype<
+27 | |            Atype<
 ...  |
-LL | |        i32
-LL | |      > = Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok...
+47 | |        i32
+48 | |      > = Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok...
    | | _____-___^
    | ||_____|
    |  |     expected due to this
-LL |  |         Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok...
-LL |  |             Ok("")
-LL |  |         ))))))))))))))))))))))))))))))
-LL |  |     )))))))))))))))))))))))))))))];
+49 |  |         Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok...
+50 |  |             Ok("")
+51 |  |         ))))))))))))))))))))))))))))))
+52 |  |     )))))))))))))))))))))))))))))];
    |  |__________________________________^ expected `Atype<Btype<Ctype<..., i32>, i32>, i32>`, found `Result<Result<Result<..., _>, _>, _>`
    |
    = note: expected struct `Atype<Btype<..., i32>, i32>`
@@ -2771,30 +2767,28 @@ LL |  |     )))))))))))))))))))))))))))))];
    = note: the full name for the type has been written to '$TEST_BUILD_DIR/$FILE.long-type-hash.txt'
    = note: consider using `--verbose` to print the full type name to the console
 "#]];
-    let renderer = Renderer::plain()
-        .term_width(60)
-        .anonymized_line_numbers(true);
+    let renderer = Renderer::plain().term_width(60);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
    ╭▸ $DIR/long-E0308.rs:48:9
    │
-LL │        let x: Atype<
+24 │        let x: Atype<
    │ ┌─────────────┘
-LL │ │        Btype<
-LL │ │          Ctype<
-LL │ │            Atype<
+25 │ │        Btype<
+26 │ │          Ctype<
+27 │ │            Atype<
    ‡ │
-LL │ │        i32
-LL │ │      > = Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(O…
+47 │ │        i32
+48 │ │      > = Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(O…
    │ │┏━━━━━│━━━┛
    │ └┃─────┤
    │  ┃     expected due to this
-LL │  ┃         Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(O…
-LL │  ┃             Ok("")
-LL │  ┃         ))))))))))))))))))))))))))))))
-LL │  ┃     )))))))))))))))))))))))))))))];
+49 │  ┃         Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(Ok(O…
+50 │  ┃             Ok("")
+51 │  ┃         ))))))))))))))))))))))))))))))
+52 │  ┃     )))))))))))))))))))))))))))))];
    │  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ expected `Atype<Btype<Ctype<..., i32>, i32>, i32>`, found `Result<Result<Result<..., _>, _>, _>`
    │
    ├ note: expected struct `Atype<Btype<..., i32>, i32>`
@@ -2865,7 +2859,7 @@ fn main() {
 error[E0308]: mismatched types
   --> $DIR/unicode-output.rs:23:11
    |
-LL |     query(wrapped_fn);
+23 |     query(wrapped_fn);
    |     ----- ^^^^^^^^^^ one type is more general than the other
    |     |
    |     arguments to this function are incorrect
@@ -2875,20 +2869,20 @@ LL |     query(wrapped_fn);
 note: function defined here
   --> $DIR/unicode-output.rs:12:10
    |
-LL |   fn query(_: fn(Box<(dyn Any + Send + '_)>) -> Pin<Box<(
+12 |   fn query(_: fn(Box<(dyn Any + Send + '_)>) -> Pin<Box<(
    |  ____-----_^
-LL | |     dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
-LL | | )>>) {}
+13 | |     dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
+14 | | )>>) {}
    | |___^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
    ╭▸ $DIR/unicode-output.rs:23:11
    │
-LL │     query(wrapped_fn);
+23 │     query(wrapped_fn);
    │     ┬──── ━━━━━━━━━━ one type is more general than the other
    │     │
    │     arguments to this function are incorrect
@@ -2898,10 +2892,10 @@ LL │     query(wrapped_fn);
 note: function defined here
    ╭▸ $DIR/unicode-output.rs:12:10
    │
-LL │   fn query(_: fn(Box<(dyn Any + Send + '_)>) -> Pin<Box<(
+12 │   fn query(_: fn(Box<(dyn Any + Send + '_)>) -> Pin<Box<(
    │ ┏━━━━─────━┛
-LL │ ┃     dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
-LL │ ┃ )>>) {}
+13 │ ┃     dyn Future<Output = Result<Box<(dyn Any + 'static)>, String>> + Send + 'static
+14 │ ┃ )>>) {}
    ╰╴┗━━━┛
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -3192,25 +3186,25 @@ fn main() {
 
     let expected_ascii = str![[r#"
 error[E0308]: mismatched types
-  --> $DIR/non-whitespace-trimming-unicode.rs:4:415
-   |
-LL | ...♧♨♩♪♫♬♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄⚅⚆⚈⚉4"; let _: () = 42;  let _: &str = "🦀☀☁☂☃☄★☆☇☈☉☊☋☌☍☎☏☐☑☒☓  ☖☗☘☙☚☛☜☝☞☟☠☡☢☣☤☥☦☧☨☩☪☫☬☭☮☯☰☱☲...
-   |                                                  --   ^^ expected `()`, found integer
-   |                                                  |
-   |                                                  expected due to this
+ --> $DIR/non-whitespace-trimming-unicode.rs:4:415
+  |
+4 | ...♦♧♨♩♪♫♬♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄⚅⚆⚈⚉4"; let _: () = 42;  let _: &str = "🦀☀☁☂☃☄★☆☇☈☉☊☋☌☍☎☏☐☑☒☓  ☖☗☘☙☚☛☜☝☞☟☠☡☢☣☤☥☦☧☨☩☪☫☬☭☮☯☰☱☲...
+  |                                                   --   ^^ expected `()`, found integer
+  |                                                   |
+  |                                                   expected due to this
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
-   ╭▸ $DIR/non-whitespace-trimming-unicode.rs:4:415
-   │
-LL │ …♥♦♧♨♩♪♫♬♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄⚅⚆⚈⚉4"; let _: () = 42;  let _: &str = "🦀☀☁☂☃☄★☆☇☈☉☊☋☌☍☎☏☐☑☒☓  ☖☗☘☙☚☛☜☝☞☟☠☡☢☣☤☥☦☧☨☩☪☫☬☭☮☯☰☱☲☳…
-   │                                                  ┬─   ━━ expected `()`, found integer
-   │                                                  │
-   ╰╴                                                 expected due to this
+  ╭▸ $DIR/non-whitespace-trimming-unicode.rs:4:415
+  │
+4 │ …♤♥♦♧♨♩♪♫♬♭♮♯♰♱♲♳♴♵♶♷♸♹♺♻♼♽♾♿⚀⚁⚂⚃⚄⚅⚆⚈⚉4"; let _: () = 42;  let _: &str = "🦀☀☁☂☃☄★☆☇☈☉☊☋☌☍☎☏☐☑☒☓  ☖☗☘☙☚☛☜☝☞☟☠☡☢☣☤☥☦☧☨☩☪☫☬☭☮☯☰☱☲☳…
+  │                                                   ┬─   ━━ expected `()`, found integer
+  │                                                   │
+  ╰╴                                                  expected due to this
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3257,39 +3251,39 @@ fn main() {
 
     let expected_ascii = str![[r#"
 error[E0369]: cannot add `&str` to `&str`
-  --> $DIR/non-1-width-unicode-multiline-label.rs:7:260
-   |
-LL | ...࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
-   |                                  -------------- ^ -------------- &str
-   |                                  |              |
-   |                                  |              `+` cannot be used to concatenate two `&str` strings
-   |                                  &str
-   |
-   = note: string concatenation requires an owned `String` on the left
+ --> $DIR/non-1-width-unicode-multiline-label.rs:7:260
+  |
+7 | ...࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
+  |                                  -------------- ^ -------------- &str
+  |                                  |              |
+  |                                  |              `+` cannot be used to concatenate two `&str` strings
+  |                                  &str
+  |
+  = note: string concatenation requires an owned `String` on the left
 help: create an owned `String` from a string reference
-   |
-LL |     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓༔༕༖༗༘༙༚༛༜༝༞༟༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿ཀཁགགྷངཅཆཇ཈ཉཊཋཌཌྷཎཏཐདདྷནཔཕབབྷམཙཚཛཛྷཝཞཟའཡརལཤཥསཧཨཀྵཪཫཬ཭཮཯཰ཱཱཱིིུུྲྀཷླྀཹེཻོཽཾཿ྄ཱྀྀྂྃ྅྆྇ྈྉྊྋྌྍྎྏྐྑྒྒྷྔྕྖྗ྘ྙྚྛྜྜྷྞྟྠྡྡྷྣྤྥྦྦྷྨྩྪྫྫྷྭྮྯྰྱྲླྴྵྶྷྸྐྵྺྻྼ྽྾྿࿀࿁࿂࿃࿄࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun.to_owned() + " really fun!";
-   |                                                                                                                                                                                         +++++++++++
+  |
+7 |     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓༔༕༖༗༘༙༚༛༜༝༞༟༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿ཀཁགགྷངཅཆཇ཈ཉཊཋཌཌྷཎཏཐདདྷནཔཕབབྷམཙཚཛཛྷཝཞཟའཡརལཤཥསཧཨཀྵཪཫཬ཭཮཯཰ཱཱཱིིུུྲྀཷླྀཹེཻོཽཾཿ྄ཱྀྀྂྃ྅྆྇ྈྉྊྋྌྍྎྏྐྑྒྒྷྔྕྖྗ྘ྙྚྛྜྜྷྞྟྠྡྡྷྣྤྥྦྦྷྨྩྪྫྫྷྭྮྯྰྱྲླྴྵྶྷྸྐྵྺྻྼ྽྾྿࿀࿁࿂࿃࿄࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun.to_owned() + " really fun!";
+  |                                                                                                                                                                                         +++++++++++
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0369]: cannot add `&str` to `&str`
-   ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:7:260
-   │
-LL │ …࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
-   │                                  ┬───────────── ┯ ────────────── &str
-   │                                  │              │
-   │                                  │              `+` cannot be used to concatenate two `&str` strings
-   │                                  &str
-   │
-   ╰ note: string concatenation requires an owned `String` on the left
+  ╭▸ $DIR/non-1-width-unicode-multiline-label.rs:7:260
+  │
+7 │ …࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun + " really fun!";
+  │                                  ┬───────────── ┯ ────────────── &str
+  │                                  │              │
+  │                                  │              `+` cannot be used to concatenate two `&str` strings
+  │                                  &str
+  │
+  ╰ note: string concatenation requires an owned `String` on the left
 help: create an owned `String` from a string reference
-   ╭╴
-LL │     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓༔༕༖༗༘༙༚༛༜༝༞༟༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿ཀཁགགྷངཅཆཇ཈ཉཊཋཌཌྷཎཏཐདདྷནཔཕབབྷམཙཚཛཛྷཝཞཟའཡརལཤཥསཧཨཀྵཪཫཬ཭཮཯཰ཱཱཱིིུུྲྀཷླྀཹེཻོཽཾཿ྄ཱྀྀྂྃ྅྆྇ྈྉྊྋྌྍྎྏྐྑྒྒྷྔྕྖྗ྘ྙྚྛྜྜྷྞྟྠྡྡྷྣྤྥྦྦྷྨྩྪྫྫྷྭྮྯྰྱྲླྴྵྶྷྸྐྵྺྻྼ྽྾྿࿀࿁࿂࿃࿄࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun.to_owned() + " really fun!";
-   ╰╴                                                                                                                                                                                        +++++++++++
+  ╭╴
+7 │     let _ = "ༀ༁༂༃༄༅༆༇༈༉༊་༌།༎༏༐༑༒༓༔༕༖༗༘༙༚༛༜༝༞༟༠༡༢༣༤༥༦༧༨༩༪༫༬༭༮༯༰༱༲༳༴༵༶༷༸༹༺༻༼༽༾༿ཀཁགགྷངཅཆཇ཈ཉཊཋཌཌྷཎཏཐདདྷནཔཕབབྷམཙཚཛཛྷཝཞཟའཡརལཤཥསཧཨཀྵཪཫཬ཭཮཯཰ཱཱཱིིུུྲྀཷླྀཹེཻོཽཾཿ྄ཱྀྀྂྃ྅྆྇ྈྉྊྋྌྍྎྏྐྑྒྒྷྔྕྖྗ྘ྙྚྛྜྜྷྞྟྠྡྡྷྣྤྥྦྦྷྨྩྪྫྫྷྭྮྯྰྱྲླྴྵྶྷྸྐྵྺྻྼ྽྾྿࿀࿁࿂࿃࿄࿅࿆࿇࿈࿉࿊࿋࿌࿍࿎࿏࿐࿑࿒࿓࿔࿕࿖࿗࿘࿙࿚"; let _a = unicode_is_fun.to_owned() + " really fun!";
+  ╰╴                                                                                                                                                                                        +++++++++++
 "#]];
 
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -3326,35 +3320,35 @@ fn foo() {
 
     let expected_ascii = str![[r#"
 error: couldn't read `$DIR/not-utf8.bin`: stream did not contain valid UTF-8
-  --> $DIR/not-utf8.rs:6:5
-   |
-LL |     include!("not-utf8.bin");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
-   |
+ --> $DIR/not-utf8.rs:6:5
+  |
+6 |     include!("not-utf8.bin");
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^
+  |
 note: byte `193` is not valid utf-8
-  --> $DIR/not-utf8.bin:1:1
-   |
-LL | �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h�␝�:�␜␇�
-   | ^
-   = note: this error originates in the macro `include` (in Nightly builds, run with -Z macro-backtrace for more info)
+ --> $DIR/not-utf8.bin:1:1
+  |
+1 | �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h�␝�:�␜␇�
+  | ^
+  = note: this error originates in the macro `include` (in Nightly builds, run with -Z macro-backtrace for more info)
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: couldn't read `$DIR/not-utf8.bin`: stream did not contain valid UTF-8
-   ╭▸ $DIR/not-utf8.rs:6:5
-   │
-LL │     include!("not-utf8.bin");
-   │     ━━━━━━━━━━━━━━━━━━━━━━━━
-   ╰╴
+  ╭▸ $DIR/not-utf8.rs:6:5
+  │
+6 │     include!("not-utf8.bin");
+  │     ━━━━━━━━━━━━━━━━━━━━━━━━
+  ╰╴
 note: byte `193` is not valid utf-8
-   ╭▸ $DIR/not-utf8.bin:1:1
-   │
-LL │ �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h�␝�:�␜␇�
-   │ ━
-   ╰ note: this error originates in the macro `include` (in Nightly builds, run with -Z macro-backtrace for more info)
+  ╭▸ $DIR/not-utf8.bin:1:1
+  │
+1 │ �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h�␝�:�␜␇�
+  │ ━
+  ╰ note: this error originates in the macro `include` (in Nightly builds, run with -Z macro-backtrace for more info)
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3392,30 +3386,30 @@ fn secondary_title_no_level_text() {
 
     let expected_ascii = str![[r#"
 error[E0308]: mismatched types
-  --> $DIR/mismatched-types.rs:3:19
-   |
-LL |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
-   |            |
-   |            expected due to this
-   |
-   = expected reference `&str`
-     found reference `&'static [u8; 0]`
+ --> $DIR/mismatched-types.rs:3:19
+  |
+3 |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
+  |            |
+  |            expected due to this
+  |
+  = expected reference `&str`
+    found reference `&'static [u8; 0]`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
-   ╭▸ $DIR/mismatched-types.rs:3:19
-   │
-LL │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
-   │            │
-   │            expected due to this
-   │
-   ╰ expected reference `&str`
-     found reference `&'static [u8; 0]`
+  ╭▸ $DIR/mismatched-types.rs:3:19
+  │
+3 │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
+  │            │
+  │            expected due to this
+  │
+  ╰ expected reference `&str`
+    found reference `&'static [u8; 0]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3453,30 +3447,30 @@ fn secondary_title_custom_level_text() {
 
     let expected_ascii = str![[r#"
 error[E0308]: mismatched types
-  --> $DIR/mismatched-types.rs:3:19
-   |
-LL |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
-   |            |
-   |            expected due to this
-   |
-   = custom: expected reference `&str`
-             found reference `&'static [u8; 0]`
+ --> $DIR/mismatched-types.rs:3:19
+  |
+3 |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
+  |            |
+  |            expected due to this
+  |
+  = custom: expected reference `&str`
+            found reference `&'static [u8; 0]`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
-   ╭▸ $DIR/mismatched-types.rs:3:19
-   │
-LL │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
-   │            │
-   │            expected due to this
-   │
-   ╰ custom: expected reference `&str`
-             found reference `&'static [u8; 0]`
+  ╭▸ $DIR/mismatched-types.rs:3:19
+  │
+3 │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
+  │            │
+  │            expected due to this
+  │
+  ╰ custom: expected reference `&str`
+            found reference `&'static [u8; 0]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3546,42 +3540,42 @@ fn main() {
 error[E0571]: `break` with value from a `while` loop
   --> $DIR/issue-114529-illegal-break-with-value.rs:22:9
    |
-LL |       while true {
+21 |       while true {
    |       ---------- you can't `break` with a value in a `while` loop
-LL | /         break (|| { //~ ERROR `break` with value from a `while` loop
-LL | |             let local = 9;
-LL | |         });
+22 | /         break (|| { //~ ERROR `break` with value from a `while` loop
+23 | |             let local = 9;
+24 | |         });
    | |__________^ can only break with a value inside `loop` or breakable block
    |
 suggestion[S0123]: use `break` on its own without a value inside this `while` loop
    |
-LL -         break (|| { //~ ERROR `break` with value from a `while` loop
-LL -             let local = 9;
-LL -         });
-LL +         break;
+22 -         break (|| { //~ ERROR `break` with value from a `while` loop
+23 -             let local = 9;
+24 -         });
+22 +         break;
    |
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0571]: `break` with value from a `while` loop
    ╭▸ $DIR/issue-114529-illegal-break-with-value.rs:22:9
    │
-LL │       while true {
+21 │       while true {
    │       ────────── you can't `break` with a value in a `while` loop
-LL │ ┏         break (|| { //~ ERROR `break` with value from a `while` loop
-LL │ ┃             let local = 9;
-LL │ ┃         });
+22 │ ┏         break (|| { //~ ERROR `break` with value from a `while` loop
+23 │ ┃             let local = 9;
+24 │ ┃         });
    │ ┗━━━━━━━━━━┛ can only break with a value inside `loop` or breakable block
    ╰╴
 suggestion[S0123]: use `break` on its own without a value inside this `while` loop
    ╭╴
-LL -         break (|| { //~ ERROR `break` with value from a `while` loop
-LL -             let local = 9;
-LL -         });
-LL +         break;
+22 -         break (|| { //~ ERROR `break` with value from a `while` loop
+23 -             let local = 9;
+24 -         });
+22 +         break;
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4104,18 +4098,18 @@ fn main() {}
 error[E0282]: type annotations needed
   --> $DIR/issue-42234-unknown-receiver-type.rs:12:10
    |
-LL |         .sum::<_>() //~ ERROR type annotations needed
+12 |         .sum::<_>() //~ ERROR type annotations needed
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0282]: type annotations needed
    ╭▸ $DIR/issue-42234-unknown-receiver-type.rs:12:10
    │
-LL │         .sum::<_>() //~ ERROR type annotations needed
+12 │         .sum::<_>() //~ ERROR type annotations needed
    │          ━━━ cannot infer type of the type parameter `S` declared on the method `sum`
    ╰╴
 "#]];
@@ -4170,29 +4164,29 @@ fn main() {}
 error[E0282]: type annotations needed
   --> $DIR/issue-42234-unknown-receiver-type.rs:12:10
    |
-LL |         .sum::<_>() //~ ERROR type annotations needed
+12 |         .sum::<_>() //~ ERROR type annotations needed
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
    |
 help: consider specifying the generic argument
    |
-LL -         .sum::<_>() //~ ERROR type annotations needed
-LL +         .sum::<GENERIC_ARG>() //~ ERROR type annotations needed
+23 -         .sum::<_>() //~ ERROR type annotations needed
+23 +         .sum::<GENERIC_ARG>() //~ ERROR type annotations needed
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0282]: type annotations needed
    ╭▸ $DIR/issue-42234-unknown-receiver-type.rs:12:10
    │
-LL │         .sum::<_>() //~ ERROR type annotations needed
+12 │         .sum::<_>() //~ ERROR type annotations needed
    │          ━━━ cannot infer type of the type parameter `S` declared on the method `sum`
    ╰╴
 help: consider specifying the generic argument
    ╭╴
-LL -         .sum::<_>() //~ ERROR type annotations needed
-LL +         .sum::<GENERIC_ARG>() //~ ERROR type annotations needed
+23 -         .sum::<_>() //~ ERROR type annotations needed
+23 +         .sum::<GENERIC_ARG>() //~ ERROR type annotations needed
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4244,27 +4238,27 @@ fn main() {}
 error[E0282]: type annotations needed
   --> $DIR/issue-42234-unknown-receiver-type.rs:12:10
    |
-LL |         .sum::<_>() //~ ERROR type annotations needed
+12 |         .sum::<_>() //~ ERROR type annotations needed
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
    |
 help: consider specifying the generic argument
    |
-LL |         .sum::<_>() //~ ERROR type annotations needed
+23 |         .sum::<_>() //~ ERROR type annotations needed
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0282]: type annotations needed
    ╭▸ $DIR/issue-42234-unknown-receiver-type.rs:12:10
    │
-LL │         .sum::<_>() //~ ERROR type annotations needed
+12 │         .sum::<_>() //~ ERROR type annotations needed
    │          ━━━ cannot infer type of the type parameter `S` declared on the method `sum`
    ╰╴
 help: consider specifying the generic argument
    ╭╴
-LL │         .sum::<_>() //~ ERROR type annotations needed
+23 │         .sum::<_>() //~ ERROR type annotations needed
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4416,10 +4410,10 @@ error[E0609]: no field `field` on type `Thing`
    = note: a `Title` then a `Message`!?!?
   --> $DIR/too-many-field-suggestions.rs:26:7
    |
-LL |     t.field;
+26 |     t.field;
    |       ^^^^^ unknown field
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
@@ -4428,7 +4422,7 @@ error[E0609]: no field `field` on type `Thing`
    ├ note: a `Title` then a `Message`!?!?
    ├▸ $DIR/too-many-field-suggestions.rs:26:7
    │
-LL │     t.field;
+26 │     t.field;
    ╰╴      ━━━━━ unknown field
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);

From 131daccc1ce6a6b1f9ef5a66ad1887527db827cb Mon Sep 17 00:00:00 2001
From: Scott Schafer <schaferjscott@gmail.com>
Date: Tue, 28 Oct 2025 15:54:31 -0600
Subject: [PATCH 4/4] test: Switch rustc_tests to use line numbers

---
 tests/rustc_tests.rs | 1305 +++++++++++++++++++++---------------------
 1 file changed, 643 insertions(+), 662 deletions(-)

diff --git a/tests/rustc_tests.rs b/tests/rustc_tests.rs
index 4990a05b..6981d384 100644
--- a/tests/rustc_tests.rs
+++ b/tests/rustc_tests.rs
@@ -1157,28 +1157,28 @@ fn f(){||yield(((){),
         )];
     let expected_ascii = str![[r#"
 error: this file contains an unclosed delimiter
-  --> $DIR/issue-91334.rs:7:23
-   |
-LL | fn f(){||yield(((){),
-   |       -       -    - ^
-   |       |       |    |
-   |       |       |    missing open `(` for this delimiter
-   |       |       unclosed delimiter
-   |       unclosed delimiter
-"#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+ --> $DIR/issue-91334.rs:7:23
+  |
+7 | fn f(){||yield(((){),
+  |       -       -    - ^
+  |       |       |    |
+  |       |       |    missing open `(` for this delimiter
+  |       |       unclosed delimiter
+  |       unclosed delimiter
+"#]];
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: this file contains an unclosed delimiter
-   ╭▸ $DIR/issue-91334.rs:7:23
-   │
-LL │ fn f(){||yield(((){),
-   │       ┬       ┬    ┬ ━
-   │       │       │    │
-   │       │       │    missing open `(` for this delimiter
-   │       │       unclosed delimiter
-   ╰╴      unclosed delimiter
+  ╭▸ $DIR/issue-91334.rs:7:23
+  │
+7 │ fn f(){||yield(((){),
+  │       ┬       ┬    ┬ ━
+  │       │       │    │
+  │       │       │    missing open `(` for this delimiter
+  │       │       unclosed delimiter
+  ╰╴      unclosed delimiter
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1246,42 +1246,42 @@ fn main() {
 error[E0571]: `break` with value from a `while` loop
   --> $DIR/issue-114529-illegal-break-with-value.rs:22:9
    |
-LL |       while true {
+21 |       while true {
    |       ---------- you can't `break` with a value in a `while` loop
-LL | /         break (|| { //~ ERROR `break` with value from a `while` loop
-LL | |             let local = 9;
-LL | |         });
+22 | /         break (|| { //~ ERROR `break` with value from a `while` loop
+23 | |             let local = 9;
+24 | |         });
    | |__________^ can only break with a value inside `loop` or breakable block
    |
 help: use `break` on its own without a value inside this `while` loop
   --> $DIR/issue-114529-illegal-break-with-value.rs:22:9
    |
-LL | /         break (|| { //~ ERROR `break` with value from a `while` loop
-LL | |             let local = 9;
-LL | |         });
+22 | /         break (|| { //~ ERROR `break` with value from a `while` loop
+23 | |             let local = 9;
+24 | |         });
    | |__________- break
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0571]: `break` with value from a `while` loop
    ╭▸ $DIR/issue-114529-illegal-break-with-value.rs:22:9
    │
-LL │       while true {
+21 │       while true {
    │       ────────── you can't `break` with a value in a `while` loop
-LL │ ┏         break (|| { //~ ERROR `break` with value from a `while` loop
-LL │ ┃             let local = 9;
-LL │ ┃         });
+22 │ ┏         break (|| { //~ ERROR `break` with value from a `while` loop
+23 │ ┃             let local = 9;
+24 │ ┃         });
    │ ┗━━━━━━━━━━┛ can only break with a value inside `loop` or breakable block
    ╰╴
 help: use `break` on its own without a value inside this `while` loop
    ╭▸ $DIR/issue-114529-illegal-break-with-value.rs:22:9
    │
-LL │ ┌         break (|| { //~ ERROR `break` with value from a `while` loop
-LL │ │             let local = 9;
-LL │ │         });
+22 │ ┌         break (|| { //~ ERROR `break` with value from a `while` loop
+23 │ │             let local = 9;
+24 │ │         });
    ╰╴└──────────┘ break
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1471,50 +1471,50 @@ fn nsize() {
         ];
     let expected_ascii = str![[r#"
 error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]`
-  --> $DIR/primitive_reprs_should_have_correct_length.rs:144:44
-   |
-LL |         assert::is_transmutable::<Current, Larger>(); //~ ERROR cannot be safely transmuted
-   |                                            ^^^^^^ the size of `V0usize` is smaller than the size of `[usize; 2]`
-   |
+   --> $DIR/primitive_reprs_should_have_correct_length.rs:144:44
+    |
+144 |         assert::is_transmutable::<Current, Larger>(); //~ ERROR cannot be safely transmuted
+    |                                            ^^^^^^ the size of `V0usize` is smaller than the size of `[usize; 2]`
+    |
 note: required by a bound in `is_transmutable`
-  --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
-   |
-LL |       pub fn is_transmutable<Src, Dst>()
-   |              --------------- required by a bound in this function
-LL |       where
-LL |           Dst: TransmuteFrom<Src, {
-   |  ______________^
-LL | |             Assume {
-LL | |                 alignment: true,
-LL | |                 lifetimes: true,
-...  |
-LL | |         }>
-   | |__________^ required by this bound in `is_transmutable`
+   --> $DIR/primitive_reprs_should_have_correct_length.rs:12:14
+    |
+ 10 |       pub fn is_transmutable<Src, Dst>()
+    |              --------------- required by a bound in this function
+ 11 |       where
+ 12 |           Dst: TransmuteFrom<Src, {
+    |  ______________^
+ 13 | |             Assume {
+ 14 | |                 alignment: true,
+ 15 | |                 lifetimes: true,
+...   |
+ 19 | |         }>
+    | |__________^ required by this bound in `is_transmutable`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0277]: `V0usize` cannot be safely transmuted into `[usize; 2]`
-   ╭▸ $DIR/primitive_reprs_should_have_correct_length.rs:144:44
-   │
-LL │         assert::is_transmutable::<Current, Larger>(); //~ ERROR cannot be safely transmuted
-   │                                            ━━━━━━ the size of `V0usize` is smaller than the size of `[usize; 2]`
-   ╰╴
+    ╭▸ $DIR/primitive_reprs_should_have_correct_length.rs:144:44
+    │
+144 │         assert::is_transmutable::<Current, Larger>(); //~ ERROR cannot be safely transmuted
+    │                                            ━━━━━━ the size of `V0usize` is smaller than the size of `[usize; 2]`
+    ╰╴
 note: required by a bound in `is_transmutable`
-   ╭▸ $DIR/primitive_reprs_should_have_correct_length.rs:12:14
-   │
-LL │       pub fn is_transmutable<Src, Dst>()
-   │              ─────────────── required by a bound in this function
-LL │       where
-LL │           Dst: TransmuteFrom<Src, {
-   │ ┏━━━━━━━━━━━━━━┛
-LL │ ┃             Assume {
-LL │ ┃                 alignment: true,
-LL │ ┃                 lifetimes: true,
-   ‡ ┃
-LL │ ┃         }>
-   ╰╴┗━━━━━━━━━━┛ required by this bound in `is_transmutable`
+    ╭▸ $DIR/primitive_reprs_should_have_correct_length.rs:12:14
+    │
+ 10 │       pub fn is_transmutable<Src, Dst>()
+    │              ─────────────── required by a bound in this function
+ 11 │       where
+ 12 │           Dst: TransmuteFrom<Src, {
+    │ ┏━━━━━━━━━━━━━━┛
+ 13 │ ┃             Assume {
+ 14 │ ┃                 alignment: true,
+ 15 │ ┃                 lifetimes: true,
+    ‡ ┃
+ 19 │ ┃         }>
+    ╰╴┗━━━━━━━━━━┛ required by this bound in `is_transmutable`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1563,17 +1563,17 @@ fn main() {
 error[E027s7]: `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
   --> $DIR/align-fail.rs:21:55
    |
-LL | ...ic [u8; 0], &'static [u16; 0]>(); //~ ERROR `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
+21 | ...ic [u8; 0], &'static [u16; 0]>(); //~ ERROR `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
    |                ^^^^^^^^^^^^^^^^^ the minimum alignment of `&[u8; 0]` (1) should be greater than that of `&[u16; 0]` (2)
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E027s7]: `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
    ╭▸ $DIR/align-fail.rs:21:55
    │
-LL │ …atic [u8; 0], &'static [u16; 0]>(); //~ ERROR `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
+21 │ …atic [u8; 0], &'static [u16; 0]>(); //~ ERROR `&[u8; 0]` cannot be safely transmuted into `&[u16; 0]`
    ╰╴               ━━━━━━━━━━━━━━━━━ the minimum alignment of `&[u8; 0]` (1) should be greater than that of `&[u16; 0]` (2)
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1647,33 +1647,33 @@ fn main() {}
             )];
     let expected_ascii = str![[r#"
 error[E0618]: expected function, found `{integer}`
-  --> $DIR/missing-semicolon.rs:5:13
-   |
-LL |       let x = 5;
-   |           - `x` has type `{integer}`
-LL |       let y = x //~ ERROR expected function
-   |               ^- help: consider using a semicolon here to finish the statement: `;`
-   |  _____________|
-   | |
-LL | |     () //~ ERROR expected `;`, found `}`
-   | |______- call expression requires function
+ --> $DIR/missing-semicolon.rs:5:13
+  |
+4 |       let x = 5;
+  |           - `x` has type `{integer}`
+5 |       let y = x //~ ERROR expected function
+  |               ^- help: consider using a semicolon here to finish the statement: `;`
+  |  _____________|
+  | |
+6 | |     () //~ ERROR expected `;`, found `}`
+  | |______- call expression requires function
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0618]: expected function, found `{integer}`
-   ╭▸ $DIR/missing-semicolon.rs:5:13
-   │
-LL │       let x = 5;
-   │           ─ `x` has type `{integer}`
-LL │       let y = x //~ ERROR expected function
-   │               ━─ help: consider using a semicolon here to finish the statement: `;`
-   │ ┌─────────────┘
-   │ │
-LL │ │     () //~ ERROR expected `;`, found `}`
-   ╰╴└──────┘ call expression requires function
+  ╭▸ $DIR/missing-semicolon.rs:5:13
+  │
+4 │       let x = 5;
+  │           ─ `x` has type `{integer}`
+5 │       let y = x //~ ERROR expected function
+  │               ━─ help: consider using a semicolon here to finish the statement: `;`
+  │ ┌─────────────┘
+  │ │
+6 │ │     () //~ ERROR expected `;`, found `}`
+  ╰╴└──────┘ call expression requires function
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -1773,20 +1773,20 @@ outer_macro!(FirstStruct, FirstAttrStruct);
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
   --> $DIR/auxiliary/nested-macro-rules.rs:7:9
    |
-LL |   macro_rules! outer_macro {
+ 4 |   macro_rules! outer_macro {
    |   ------------------------ in this expansion of `nested_macro_rules::outer_macro!`
 ...
-LL | /         macro_rules! inner_macro {
-LL | |             ($bang_macro:ident, $attr_macro:ident) => {
-LL | |                 $bang_macro!($name);
-LL | |                 #[$attr_macro] struct $attr_struct_name {}
-LL | |             }
-LL | |         }
+ 7 | /         macro_rules! inner_macro {
+ 8 | |             ($bang_macro:ident, $attr_macro:ident) => {
+ 9 | |                 $bang_macro!($name);
+10 | |                 #[$attr_macro] struct $attr_struct_name {}
+11 | |             }
+12 | |         }
    | |_________^
    |
   ::: $DIR/nested-macro-rules.rs:23:5
    |
-LL |       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
+23 |       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
    |       ---------------------------------------------------------------- in this macro invocation
    |
    = help: remove the `#[macro_export]` or move this `macro_rules!` outside the of the current function `main`
@@ -1794,30 +1794,30 @@ LL |       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
 note: the lint level is defined here
   --> $DIR/nested-macro-rules.rs:8:9
    |
-LL | #![warn(non_local_definitions)]
+ 8 | #![warn(non_local_definitions)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
    ╭▸ $DIR/auxiliary/nested-macro-rules.rs:7:9
    │
-LL │   macro_rules! outer_macro {
+ 4 │   macro_rules! outer_macro {
    │   ──────────────────────── in this expansion of `nested_macro_rules::outer_macro!`
    ‡
-LL │ ┏         macro_rules! inner_macro {
-LL │ ┃             ($bang_macro:ident, $attr_macro:ident) => {
-LL │ ┃                 $bang_macro!($name);
-LL │ ┃                 #[$attr_macro] struct $attr_struct_name {}
-LL │ ┃             }
-LL │ ┃         }
+ 7 │ ┏         macro_rules! inner_macro {
+ 8 │ ┃             ($bang_macro:ident, $attr_macro:ident) => {
+ 9 │ ┃                 $bang_macro!($name);
+10 │ ┃                 #[$attr_macro] struct $attr_struct_name {}
+11 │ ┃             }
+12 │ ┃         }
    │ ┗━━━━━━━━━┛
    │
    ⸬  $DIR/nested-macro-rules.rs:23:5
    │
-LL │       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
+23 │       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
    │       ──────────────────────────────────────────────────────────────── in this macro invocation
    │
    ├ help: remove the `#[macro_export]` or move this `macro_rules!` outside the of the current function `main`
@@ -1825,7 +1825,7 @@ LL │       nested_macro_rules::outer_macro!(SecondStruct, SecondAttrStruct);
 note: the lint level is defined here
    ╭▸ $DIR/nested-macro-rules.rs:8:9
    │
-LL │ #![warn(non_local_definitions)]
+ 8 │ #![warn(non_local_definitions)]
    ╰╴        ━━━━━━━━━━━━━━━━━━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1909,29 +1909,29 @@ macro_rules! inline {
 error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
   --> $DIR/method-on-ambiguous-numeric-type.rs:37:9
    |
-LL |     bar.pow(2);
+37 |     bar.pow(2);
    |         ^^^
    |
 help: you must specify a type for this binding, like `i32`
   --> $DIR/auxiliary/macro-in-other-crate.rs:3:35
    |
-LL |     ($ident:ident) => { let $ident = 42; }
+ 3 |     ($ident:ident) => { let $ident = 42; }
    |                                   - : i32
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
    ╭▸ $DIR/method-on-ambiguous-numeric-type.rs:37:9
    │
-LL │     bar.pow(2);
+37 │     bar.pow(2);
    │         ━━━
    ╰╴
 help: you must specify a type for this binding, like `i32`
    ╭▸ $DIR/auxiliary/macro-in-other-crate.rs:3:35
    │
-LL │     ($ident:ident) => { let $ident = 42; }
+ 3 │     ($ident:ident) => { let $ident = 42; }
    ╰╴                                  ─ : i32
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -1977,17 +1977,17 @@ fn main() {}
 error[E0282]: type annotations needed
   --> $DIR/issue-42234-unknown-receiver-type.rs:15:10
    |
-LL |         .sum::<_>() //~ ERROR type annotations needed
+15 |         .sum::<_>() //~ ERROR type annotations needed
    |          ^^^ cannot infer type of the type parameter `S` declared on the method `sum`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0282]: type annotations needed
    ╭▸ $DIR/issue-42234-unknown-receiver-type.rs:15:10
    │
-LL │         .sum::<_>() //~ ERROR type annotations needed
+15 │         .sum::<_>() //~ ERROR type annotations needed
    ╰╴         ━━━ cannot infer type of the type parameter `S` declared on the method `sum`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2121,66 +2121,65 @@ fn main() {}
 error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
   --> $DIR/empty-match.rs:71:24
    |
-LL |     match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
+71 |     match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    |                        ^^^^^^^^^^^^^^^^^ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    |
 note: `NonEmptyEnum5` defined here
   --> $DIR/empty-match.rs:38:10
    |
-LL |     enum NonEmptyEnum5 {
+38 |     enum NonEmptyEnum5 {
    |          ^^^^^^^^^^^^^
-LL |         V1,
+39 |         V1,
    |         -- not covered
-LL |         V2,
+40 |         V2,
    |         -- not covered
-LL |         V3,
+41 |         V3,
    |         -- not covered
-LL |         V4,
+42 |         V4,
    |         -- not covered
-LL |         V5,
+43 |         V5,
    |         -- not covered
    = note: the matched value is of type `NonEmptyEnum5`
    = note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown, or multiple match arms
   --> $DIR/empty-match.rs:17:33
    |
-LL |                 _ if false => {}
+17 |                 _ if false => {}
    |                                 - ,
                 _ => todo!()
 "#]];
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .term_width(annotate_snippets::renderer::DEFAULT_TERM_WIDTH + 4);
+    let renderer =
+        Renderer::plain().term_width(annotate_snippets::renderer::DEFAULT_TERM_WIDTH + 4);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0004]: non-exhaustive patterns: `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    ╭▸ $DIR/empty-match.rs:71:24
    │
-LL │     match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
+71 │     match_guarded_arm!(NonEmptyEnum5::V1); //~ ERROR `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    │                        ━━━━━━━━━━━━━━━━━ patterns `NonEmptyEnum5::V1`, `NonEmptyEnum5::V2`, `NonEmptyEnum5::V3` and 2 more not covered
    ╰╴
 note: `NonEmptyEnum5` defined here
    ╭▸ $DIR/empty-match.rs:38:10
    │
-LL │     enum NonEmptyEnum5 {
+38 │     enum NonEmptyEnum5 {
    │          ━━━━━━━━━━━━━
-LL │         V1,
+39 │         V1,
    │         ── not covered
-LL │         V2,
+40 │         V2,
    │         ── not covered
-LL │         V3,
+41 │         V3,
    │         ── not covered
-LL │         V4,
+42 │         V4,
    │         ── not covered
-LL │         V5,
+43 │         V5,
    │         ── not covered
    ├ note: the matched value is of type `NonEmptyEnum5`
    ╰ note: match arms with guards don't count towards exhaustivity
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown, or multiple match arms
    ╭▸ $DIR/empty-match.rs:17:33
    │
-LL │                 _ if false => {}
+17 │                 _ if false => {}
    ╰╴                                ─ ,
                 _ => todo!()
 "#]];
@@ -2238,43 +2237,43 @@ fn main() {
                 )];
     let expected_ascii = str![[r#"
 error[E0038]: the trait alias `EqAlias` is not dyn compatible
-  --> $DIR/object-fail.rs:7:17
-   |
-LL |     let _: &dyn EqAlias = &123;
-   |                 ^^^^^^^ `EqAlias` is not dyn compatible
-   |
+ --> $DIR/object-fail.rs:7:17
+  |
+7 |     let _: &dyn EqAlias = &123;
+  |                 ^^^^^^^ `EqAlias` is not dyn compatible
+  |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $SRC_DIR/core/src/cmp.rs:334:14
-   |
-   = note: ...because it uses `Self` as a type parameter
-   |
-  ::: $DIR/object-fail.rs:3:7
-   |
-LL | trait EqAlias = Eq;
-   |       ------- this trait is not dyn compatible...
+ --> $SRC_DIR/core/src/cmp.rs:334:14
+  |
+  = note: ...because it uses `Self` as a type parameter
+  |
+ ::: $DIR/object-fail.rs:3:7
+  |
+3 | trait EqAlias = Eq;
+  |       ------- this trait is not dyn compatible...
 "#]];
 
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: the trait alias `EqAlias` is not dyn compatible
-   ╭▸ $DIR/object-fail.rs:7:17
-   │
-LL │     let _: &dyn EqAlias = &123;
-   │                 ━━━━━━━ `EqAlias` is not dyn compatible
-   ╰╴
+  ╭▸ $DIR/object-fail.rs:7:17
+  │
+7 │     let _: &dyn EqAlias = &123;
+  │                 ━━━━━━━ `EqAlias` is not dyn compatible
+  ╰╴
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-   ╭▸ $SRC_DIR/core/src/cmp.rs:334:14
-   │
-   ├ note: ...because it uses `Self` as a type parameter
-   │
-   ⸬  $DIR/object-fail.rs:3:7
-   │
-LL │ trait EqAlias = Eq;
-   ╰╴      ─────── this trait is not dyn compatible...
+  ╭▸ $SRC_DIR/core/src/cmp.rs:334:14
+  │
+  ├ note: ...because it uses `Self` as a type parameter
+  │
+  ⸬  $DIR/object-fail.rs:3:7
+  │
+3 │ trait EqAlias = Eq;
+  ╰╴      ─────── this trait is not dyn compatible...
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2302,23 +2301,21 @@ fn main() {}
         )];
     let expected_ascii = str![[r#"
 error[E0038]: mismatched types
-  --> $DIR/long-span.rs:2:15
-   |
-LL | ... = [0, 0, 0...0];
-   |       ^^^^^^^^...^^ expected `u8`, found `[{integer}; 1680]`
+ --> $DIR/long-span.rs:2:15
+  |
+2 | ... = [0, 0, 0,...];
+  |       ^^^^^^^^^...^ expected `u8`, found `[{integer}; 1680]`
 "#]];
 
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .term_width(8);
+    let renderer = Renderer::plain().term_width(8);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0…0];
-   ╰╴      ━━━━━━━━…━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0,…];
+  ╰╴      ━━━━━━━━━…━ expected `u8`, found `[{integer}; 1680]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2346,24 +2343,23 @@ fn main() {}
         )];
     let expected_ascii = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0…0];
-   ╰╴      ━━━━━━━━…━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0,…];
+  ╰╴      ━━━━━━━━━…━ expected `u8`, found `[{integer}; 1680]`
 "#]];
 
     let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
         .term_width(12)
         .decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0…0];
-   ╰╴      ━━━━━━━━…━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0,…];
+  ╰╴      ━━━━━━━━━…━ expected `u8`, found `[{integer}; 1680]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2391,24 +2387,23 @@ fn main() {}
         )];
     let expected_ascii = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, …, 0, 0, 0, 0, 0, 0, 0];
-   ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0… 0, 0, 0, 0, 0, 0, 0];
+  ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
 "#]];
 
     let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
         .term_width(80)
         .decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, …, 0, 0, 0, 0, 0, 0, 0];
-   ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0… 0, 0, 0, 0, 0, 0, 0];
+  ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2436,23 +2431,21 @@ fn main() {}
         )];
     let expected_ascii = str![[r#"
 error[E0038]: mismatched types
-  --> $DIR/long-span.rs:2:15
-   |
-LL | ... = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0...0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `[{integer}; 1680]`
+ --> $DIR/long-span.rs:2:15
+  |
+2 | ... = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,..., 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `[{integer}; 1680]`
 "#]];
 
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .term_width(120);
+    let renderer = Renderer::plain().term_width(120);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: mismatched types
-   ╭▸ $DIR/long-span.rs:2:15
-   │
-LL │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-   ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
+  ╭▸ $DIR/long-span.rs:2:15
+  │
+2 │ …u8 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,…, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  ╰╴      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━…━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `u8`, found `[{integer}; 1680]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2518,15 +2511,15 @@ fn main() {
 error: `Iterator::map` call that discard the iterator's values
   --> $DIR/lint_map_unit_fn.rs:11:18
    |
-LL |         x.iter_mut().map(|items| {
+11 |         x.iter_mut().map(|items| {
    |                      ^   -------
    |                      |   |
    |  ____________________|___this function returns `()`, which is likely not what you wanted
    | |  __________________|
    | | |
-LL | | |     //~^ ERROR `Iterator::map` call that discard the iterator's values
-LL | | |         items.sort();
-LL | | |     });
+12 | | |     //~^ ERROR `Iterator::map` call that discard the iterator's values
+13 | | |         items.sort();
+14 | | |     });
    | | |     -^ after this call to map, the resulting iterator is `impl Iterator<Item = ()>`, which means the only information carried by the iterator is the number of items
    | | |_____||
    | |_______|
@@ -2535,26 +2528,26 @@ LL | | |     });
    = note: `Iterator::map`, like many of the methods on `Iterator`, gets executed lazily, meaning that its effects won't be visible until it is iterated
 help: you might have meant to use `Iterator::for_each`
    |
-LL -     x.iter_mut().map(|items| {
-LL +     x.iter_mut().for_each(|items| {
+11 -     x.iter_mut().map(|items| {
+11 +     x.iter_mut().for_each(|items| {
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: `Iterator::map` call that discard the iterator's values
    ╭▸ $DIR/lint_map_unit_fn.rs:11:18
    │
-LL │         x.iter_mut().map(|items| {
+11 │         x.iter_mut().map(|items| {
    │                      ╿   │──────
    │                      │   │
    │ ┌────────────────────│───this function returns `()`, which is likely not what you wanted
    │ │ ┏━━━━━━━━━━━━━━━━━━┙
    │ │ ┃
-LL │ │ ┃     //~^ ERROR `Iterator::map` call that discard the iterator's values
-LL │ │ ┃         items.sort();
-LL │ │ ┃     });
+12 │ │ ┃     //~^ ERROR `Iterator::map` call that discard the iterator's values
+13 │ │ ┃         items.sort();
+14 │ │ ┃     });
    │ │ ┃     │╿ after this call to map, the resulting iterator is `impl Iterator<Item = ()>`, which means the only information carried by the iterator is the number of items
    │ │ ┗━━━━━││
    │ └───────┤
@@ -2563,8 +2556,8 @@ LL │ │ ┃     });
    ╰ note: `Iterator::map`, like many of the methods on `Iterator`, gets executed lazily, meaning that its effects won't be visible until it is iterated
 help: you might have meant to use `Iterator::for_each`
    ╭╴
-LL -     x.iter_mut().map(|items| {
-LL +     x.iter_mut().for_each(|items| {
+11 -     x.iter_mut().map(|items| {
+11 +     x.iter_mut().for_each(|items| {
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2619,31 +2612,31 @@ fn main() {
 error: character constant must be escaped: `/n`
   --> $DIR/bad-char-literals.rs:10:6
    |
-LL |       '
+10 |       '
    |  ______^
-LL | | ';
+11 | | ';
    | |_^
    |
 help: escape the character
    |
-LL |     '/n';
+10 |     '/n';
    |      ++
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: character constant must be escaped: `/n`
    ╭▸ $DIR/bad-char-literals.rs:10:6
    │
-LL │       '
+10 │       '
    │ ┏━━━━━━┛
-LL │ ┃ ';
+11 │ ┃ ';
    │ ┗━┛
    ╰╴
 help: escape the character
    ╭╴
-LL │     '/n';
+10 │     '/n';
    ╰╴     ++
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2682,36 +2675,36 @@ fn main() {}
     ];
     let expected_ascii = str![[r#"
 error: unclosed frontmatter
-  --> $DIR/unclosed-1.rs:1:1
-   |
-LL | / ----cargo
-...  |
-LL | |
-   | |_^
-   |
+ --> $DIR/unclosed-1.rs:1:1
+  |
+1 | / ----cargo
+... |
+7 | |
+  | |_^
+  |
 note: frontmatter opening here was not closed
-  --> $DIR/unclosed-1.rs:1:1
-   |
-LL | ----cargo
-   | ^^^^
+ --> $DIR/unclosed-1.rs:1:1
+  |
+1 | ----cargo
+  | ^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: unclosed frontmatter
-   ╭▸ $DIR/unclosed-1.rs:1:1
-   │
-LL │ ┏ ----cargo
-   ‡ ┃
-LL │ ┃
-   │ ┗━┛
-   ╰╴
+  ╭▸ $DIR/unclosed-1.rs:1:1
+  │
+1 │ ┏ ----cargo
+  ‡ ┃
+7 │ ┃
+  │ ┗━┛
+  ╰╴
 note: frontmatter opening here was not closed
-   ╭▸ $DIR/unclosed-1.rs:1:1
-   │
-LL │ ----cargo
-   ╰╴━━━━
+  ╭▸ $DIR/unclosed-1.rs:1:1
+  │
+1 │ ----cargo
+  ╰╴━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2756,35 +2749,35 @@ fn foo() -> &str {
 error: unclosed frontmatter
   --> $DIR/unclosed-2.rs:1:1
    |
-LL | / ----cargo
+ 1 | / ----cargo
 ...  |
-LL | |     "----"
-LL | | }
+14 | |     "----"
+15 | | }
    | |__^
    |
 note: frontmatter opening here was not closed
   --> $DIR/unclosed-2.rs:1:1
    |
-LL | ----cargo
+ 1 | ----cargo
    | ^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: unclosed frontmatter
    ╭▸ $DIR/unclosed-2.rs:1:1
    │
-LL │ ┏ ----cargo
+ 1 │ ┏ ----cargo
    ‡ ┃
-LL │ ┃     "----"
-LL │ ┃ }
+14 │ ┃     "----"
+15 │ ┃ }
    │ ┗━━┛
    ╰╴
 note: frontmatter opening here was not closed
    ╭▸ $DIR/unclosed-2.rs:1:1
    │
-LL │ ----cargo
+ 1 │ ----cargo
    ╰╴━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2833,29 +2826,29 @@ fn foo(x: i32) -> i32 {
 error: invalid preceding whitespace for frontmatter close
   --> $DIR/unclosed-3.rs:12:1
    |
-LL |     ---x
+12 |     ---x
    | ^^^^^^^^
    |
 note: frontmatter close should not be preceded by whitespace
   --> $DIR/unclosed-3.rs:12:1
    |
-LL |     ---x
+12 |     ---x
    | ^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: invalid preceding whitespace for frontmatter close
    ╭▸ $DIR/unclosed-3.rs:12:1
    │
-LL │     ---x
+12 │     ---x
    │ ━━━━━━━━
    ╰╴
 note: frontmatter close should not be preceded by whitespace
    ╭▸ $DIR/unclosed-3.rs:12:1
    │
-LL │     ---x
+12 │     ---x
    ╰╴━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -2893,36 +2886,36 @@ fn main() {}
     ];
     let expected_ascii = str![[r#"
 error: unclosed frontmatter
-  --> $DIR/unclosed-4.rs:1:1
-   |
-LL | / ----cargo
-LL | | //~^ ERROR: unclosed frontmatter
-LL | |
-   | |_^
-   |
+ --> $DIR/unclosed-4.rs:1:1
+  |
+1 | / ----cargo
+2 | | //~^ ERROR: unclosed frontmatter
+3 | |
+  | |_^
+  |
 note: frontmatter opening here was not closed
-  --> $DIR/unclosed-4.rs:1:1
-   |
-LL | ----cargo
-   | ^^^^
+ --> $DIR/unclosed-4.rs:1:1
+  |
+1 | ----cargo
+  | ^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: unclosed frontmatter
-   ╭▸ $DIR/unclosed-4.rs:1:1
-   │
-LL │ ┏ ----cargo
-LL │ ┃ //~^ ERROR: unclosed frontmatter
-LL │ ┃
-   │ ┗━┛
-   ╰╴
+  ╭▸ $DIR/unclosed-4.rs:1:1
+  │
+1 │ ┏ ----cargo
+2 │ ┃ //~^ ERROR: unclosed frontmatter
+3 │ ┃
+  │ ┗━┛
+  ╰╴
 note: frontmatter opening here was not closed
-   ╭▸ $DIR/unclosed-4.rs:1:1
-   │
-LL │ ----cargo
-   ╰╴━━━━
+  ╭▸ $DIR/unclosed-4.rs:1:1
+  │
+1 │ ----cargo
+  ╰╴━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -2961,36 +2954,36 @@ fn main() {}
 
     let expected_ascii = str![[r#"
 error: unclosed frontmatter
-  --> $DIR/unclosed-5.rs:1:1
-   |
-LL | / ----cargo
-...  |
-LL | |
-   | |_^
-   |
+ --> $DIR/unclosed-5.rs:1:1
+  |
+1 | / ----cargo
+... |
+7 | |
+  | |_^
+  |
 note: frontmatter opening here was not closed
-  --> $DIR/unclosed-5.rs:1:1
-   |
-LL | ----cargo
-   | ^^^^
+ --> $DIR/unclosed-5.rs:1:1
+  |
+1 | ----cargo
+  | ^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: unclosed frontmatter
-   ╭▸ $DIR/unclosed-5.rs:1:1
-   │
-LL │ ┏ ----cargo
-   ‡ ┃
-LL │ ┃
-   │ ┗━┛
-   ╰╴
+  ╭▸ $DIR/unclosed-5.rs:1:1
+  │
+1 │ ┏ ----cargo
+  ‡ ┃
+7 │ ┃
+  │ ┗━┛
+  ╰╴
 note: frontmatter opening here was not closed
-   ╭▸ $DIR/unclosed-5.rs:1:1
-   │
-LL │ ----cargo
-   ╰╴━━━━
+  ╭▸ $DIR/unclosed-5.rs:1:1
+  │
+1 │ ----cargo
+  ╰╴━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3124,51 +3117,51 @@ pub enum E2 {
 error[E0532]: expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
   --> $DIR/pat-tuple-field-count-cross.rs:35:9
    |
-LL |         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 |         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    |         ^^^^^^
    |
   ::: $DIR/auxiliary/declarations-for-tuple-field-count-errors.rs:11:19
    |
-LL | pub enum E1 { Z0, Z1(), S(u8, u8, u8) }
+11 | pub enum E1 { Z0, Z1(), S(u8, u8, u8) }
    |               --  -- `E1::Z1` defined here
    |               |
    |               similarly named unit variant `Z0` defined here
    |
 help: use the tuple variant pattern syntax instead
    |
-LL |         E1::Z1() => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 |         E1::Z1() => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    |               ++
 help: a unit variant with a similar name exists
    |
-LL -         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
-LL +         E1::Z0 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 -         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 +         E1::Z0 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0532]: expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    ╭▸ $DIR/pat-tuple-field-count-cross.rs:35:9
    │
-LL │         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 │         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    │         ━━━━━━
    │
    ⸬  $DIR/auxiliary/declarations-for-tuple-field-count-errors.rs:11:19
    │
-LL │ pub enum E1 { Z0, Z1(), S(u8, u8, u8) }
+11 │ pub enum E1 { Z0, Z1(), S(u8, u8, u8) }
    │               ┬─  ── `E1::Z1` defined here
    │               │
    │               similarly named unit variant `Z0` defined here
    ╰╴
 help: use the tuple variant pattern syntax instead
    ╭╴
-LL │         E1::Z1() => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 │         E1::Z1() => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    ╰╴              ++
 help: a unit variant with a similar name exists
    ╭╴
-LL -         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
-LL +         E1::Z0 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 -         E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
+35 +         E1::Z0 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -3209,44 +3202,44 @@ fn unterminated_nested_comment() {
 
     let expected_ascii = str![[r#"
 error[E0758]: unterminated block comment
-  --> $DIR/unterminated-nested-comment.rs:1:1
-   |
-LL |   /* //~ ERROR E0758
-   |   ^-
-   |   |
-   |  _unterminated block comment
-   | |
-LL | | /* */
-LL | | /*
-   | | --
-   | | |
-   | | ...as last nested comment starts here, maybe you want to close this instead?
-LL | | */
-   | |_--^
-   |   |
-   |   ...and last nested comment terminates here.
+ --> $DIR/unterminated-nested-comment.rs:1:1
+  |
+1 |   /* //~ ERROR E0758
+  |   ^-
+  |   |
+  |  _unterminated block comment
+  | |
+2 | | /* */
+3 | | /*
+  | | --
+  | | |
+  | | ...as last nested comment starts here, maybe you want to close this instead?
+4 | | */
+  | |_--^
+  |   |
+  |   ...and last nested comment terminates here.
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0758]: unterminated block comment
-   ╭▸ $DIR/unterminated-nested-comment.rs:1:1
-   │
-LL │   /* //~ ERROR E0758
-   │   ╿─
-   │   │
-   │ ┏━unterminated block comment
-   │ ┃
-LL │ ┃ /* */
-LL │ ┃ /*
-   │ ┃ ┬─
-   │ ┃ │
-   │ ┃ ...as last nested comment starts here, maybe you want to close this instead?
-LL │ ┃ */
-   │ ┗━┬─┛
-   │   │
-   ╰╴  ...and last nested comment terminates here.
+  ╭▸ $DIR/unterminated-nested-comment.rs:1:1
+  │
+1 │   /* //~ ERROR E0758
+  │   ╿─
+  │   │
+  │ ┏━unterminated block comment
+  │ ┃
+2 │ ┃ /* */
+3 │ ┃ /*
+  │ ┃ ┬─
+  │ ┃ │
+  │ ┃ ...as last nested comment starts here, maybe you want to close this instead?
+4 │ ┃ */
+  │ ┗━┬─┛
+  │   │
+  ╰╴  ...and last nested comment terminates here.
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3296,40 +3289,40 @@ fn mismatched_types1() {
 
     let expected_ascii = str![[r#"
 error[E0308]: mismatched types
-  --> $DIR/file.txt:3:1
-   |
-LL |
-   | ^ expected `&[u8]`, found `&str`
-   |
-  ::: $DIR/mismatched-types.rs:2:12
-   |
-LL |     let b: &[u8] = include_str!("file.txt");    //~ ERROR mismatched types
-   |            -----   ------------------------ in this macro invocation
-   |            |
-   |            expected due to this
-   |
-   = note: expected reference `&[u8]`
-              found reference `&'static str`
+ --> $DIR/file.txt:3:1
+  |
+3 |
+  | ^ expected `&[u8]`, found `&str`
+  |
+ ::: $DIR/mismatched-types.rs:2:12
+  |
+2 |     let b: &[u8] = include_str!("file.txt");    //~ ERROR mismatched types
+  |            -----   ------------------------ in this macro invocation
+  |            |
+  |            expected due to this
+  |
+  = note: expected reference `&[u8]`
+             found reference `&'static str`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
-   ╭▸ $DIR/file.txt:3:1
-   │
-LL │
-   │ ━ expected `&[u8]`, found `&str`
-   │
-   ⸬  $DIR/mismatched-types.rs:2:12
-   │
-LL │     let b: &[u8] = include_str!("file.txt");    //~ ERROR mismatched types
-   │            ┬────   ──────────────────────── in this macro invocation
-   │            │
-   │            expected due to this
-   │
-   ╰ note: expected reference `&[u8]`
-              found reference `&'static str`
+  ╭▸ $DIR/file.txt:3:1
+  │
+3 │
+  │ ━ expected `&[u8]`, found `&str`
+  │
+  ⸬  $DIR/mismatched-types.rs:2:12
+  │
+2 │     let b: &[u8] = include_str!("file.txt");    //~ ERROR mismatched types
+  │            ┬────   ──────────────────────── in this macro invocation
+  │            │
+  │            expected due to this
+  │
+  ╰ note: expected reference `&[u8]`
+             found reference `&'static str`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3367,30 +3360,30 @@ fn mismatched_types2() {
 
     let expected_ascii = str![[r#"
 error[E0308]: mismatched types
-  --> $DIR/mismatched-types.rs:3:19
-   |
-LL |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
-   |            |
-   |            expected due to this
-   |
-   = note: expected reference `&str`
-              found reference `&'static [u8; 0]`
+ --> $DIR/mismatched-types.rs:3:19
+  |
+3 |     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  |            ----   ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `&[u8; 0]`
+  |            |
+  |            expected due to this
+  |
+  = note: expected reference `&str`
+             found reference `&'static [u8; 0]`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
-   ╭▸ $DIR/mismatched-types.rs:3:19
-   │
-LL │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
-   │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
-   │            │
-   │            expected due to this
-   │
-   ╰ note: expected reference `&str`
-              found reference `&'static [u8; 0]`
+  ╭▸ $DIR/mismatched-types.rs:3:19
+  │
+3 │     let s: &str = include_bytes!("file.txt");   //~ ERROR mismatched types
+  │            ┬───   ━━━━━━━━━━━━━━━━━━━━━━━━━━ expected `&str`, found `&[u8; 0]`
+  │            │
+  │            expected due to this
+  │
+  ╰ note: expected reference `&str`
+             found reference `&'static [u8; 0]`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3442,9 +3435,7 @@ fn main() {
     let expected_ascii = str![[r#"
 $DIR/short-error-format.rs:6:9: error[E0308]: mismatched types: expected `u32`, found `String`
 "#]];
-    let renderer = Renderer::plain()
-        .short_message(true)
-        .anonymized_line_numbers(true);
+    let renderer = Renderer::plain().short_message(true);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str!["$DIR/short-error-format.rs:6:9: error[E0308]: mismatched types: expected `u32`, found `String`"];
@@ -3483,9 +3474,7 @@ fn main() {
     let expected_ascii = str![[r#"
 $DIR/short-error-format.rs:8:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`
 "#]];
-    let renderer = Renderer::plain()
-        .short_message(true)
-        .anonymized_line_numbers(true);
+    let renderer = Renderer::plain().short_message(true);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str!["$DIR/short-error-format.rs:8:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`"];
@@ -3537,44 +3526,42 @@ pub struct Foo; //~^ ERROR
 
     let expected_ascii = str![[r#"
 error: this URL is not a hyperlink
-  --> $DIR/diagnostic-width.rs:4:41
-   |
-LL | ... a http://link.com
-   |       ^^^^^^^^^^^^^^^
-   |
-   = note: bare URLs are not automatically turned into clickable links
+ --> $DIR/diagnostic-width.rs:4:41
+  |
+4 | ... a http://link.com
+  |       ^^^^^^^^^^^^^^^
+  |
+  = note: bare URLs are not automatically turned into clickable links
 note: the lint level is defined here
-  --> $DIR/diagnostic-width.rs:2:9
-   |
-LL | ...ny(ru...are_urls)]
-   |       ^^...^^^^^^^^
+ --> $DIR/diagnostic-width.rs:2:9
+  |
+2 | ...ny(rus...re_urls)]
+  |       ^^^...^^^^^^^
 help: use an automatic link instead
-   |
-LL | /// This is a long line that contains a <http://link.com>
-   |                                         +               +
+  |
+4 | /// This is a long line that contains a <http://link.com>
+  |                                         +               +
 "#]];
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .term_width(10);
+    let renderer = Renderer::plain().term_width(10);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: this URL is not a hyperlink
-   ╭▸ $DIR/diagnostic-width.rs:4:41
-   │
-LL │ …ns a http://link.com
-   │       ━━━━━━━━━━━━━━━
-   │
-   ╰ note: bare URLs are not automatically turned into clickable links
+  ╭▸ $DIR/diagnostic-width.rs:4:41
+  │
+4 │ …ns a http://link.com
+  │       ━━━━━━━━━━━━━━━
+  │
+  ╰ note: bare URLs are not automatically turned into clickable links
 note: the lint level is defined here
-   ╭▸ $DIR/diagnostic-width.rs:2:9
-   │
-LL │ …deny(ru…are_urls)]
-   ╰╴      ━━…━━━━━━━━
+  ╭▸ $DIR/diagnostic-width.rs:2:9
+  │
+2 │ …deny(rus…re_urls)]
+  ╰╴      ━━━…━━━━━━━
 help: use an automatic link instead
-   ╭╴
-LL │ /// This is a long line that contains a <http://link.com>
-   ╰╴                                        +               +
+  ╭╴
+4 │ /// This is a long line that contains a <http://link.com>
+  ╰╴                                        +               +
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -3742,7 +3729,7 @@ fn main() {
 error[E0369]: cannot add `Box<isize>` to `Box<isize>`
   --> $DIR/autoderef-box-no-add.rs:25:24
    |
-LL |     let z: isize = a.x + b.y;
+25 |     let z: isize = a.x + b.y;
    |                    --- ^ --- Box<isize>
    |                    |
    |                    Box<isize>
@@ -3753,14 +3740,14 @@ note: the foreign item type `Box<isize>` doesn't implement `Add`
    |
    = note: not implement `Add`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0369]: cannot add `Box<isize>` to `Box<isize>`
    ╭▸ $DIR/autoderef-box-no-add.rs:25:24
    │
-LL │     let z: isize = a.x + b.y;
+25 │     let z: isize = a.x + b.y;
    │                    ┬── ━ ─── Box<isize>
    │                    │
    │                    Box<isize>
@@ -3878,7 +3865,7 @@ fn main() {
 error[E0599]: no method named `poll` found for struct `Pin<&mut impl Future<Output = ()>>` in the current scope
   --> $DIR/dont-project-to-specializable-projection.rs:48:28
    |
-LL |         match fut.as_mut().poll(ctx) {
+48 |         match fut.as_mut().poll(ctx) {
    |                            ^^^^ method not found in `Pin<&mut impl Future<Output = ()>>`
    |
   --> $SRC_DIR/core/src/future/future.rs:104:7
@@ -3888,17 +3875,17 @@ LL |         match fut.as_mut().poll(ctx) {
    = help: items from traits can only be used if the trait is in scope
 help: trait `Future` which provides `poll` is implemented but not in scope; perhaps you want to import it
    |
-LL + use std::future::Future;
+ 6 + use std::future::Future;
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0599]: no method named `poll` found for struct `Pin<&mut impl Future<Output = ()>>` in the current scope
    ╭▸ $DIR/dont-project-to-specializable-projection.rs:48:28
    │
-LL │         match fut.as_mut().poll(ctx) {
+48 │         match fut.as_mut().poll(ctx) {
    │                            ━━━━ method not found in `Pin<&mut impl Future<Output = ()>>`
    ╰╴
    ╭▸ $SRC_DIR/core/src/future/future.rs:104:7
@@ -3908,7 +3895,7 @@ LL │         match fut.as_mut().poll(ctx) {
    ╰ help: items from traits can only be used if the trait is in scope
 help: trait `Future` which provides `poll` is implemented but not in scope; perhaps you want to import it
    ╭╴
-LL + use std::future::Future;
+ 6 + use std::future::Future;
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -3979,9 +3966,9 @@ fn main() {
 error[E0369]: binary operation `==` cannot be applied to type `(std::io::Error, Thread)`
   --> $DIR/binary-op-not-allowed-issue-125631.rs:11:9
    |
-LL |     (Error::new(ErrorKind::Other, "2"), thread::current())
+10 |     (Error::new(ErrorKind::Other, "2"), thread::current())
    |     ------------------------------------------------------ (std::io::Error, Thread)
-LL |         == (Error::new(ErrorKind::Other, "2"), thread::current());
+11 |         == (Error::new(ErrorKind::Other, "2"), thread::current());
    |         ^^ ------------------------------------------------------ (std::io::Error, Thread)
    |
 note: the foreign item types don't implement required traits for this operation to be valid
@@ -3992,16 +3979,16 @@ note: the foreign item types don't implement required traits for this operation
    |
    = note: not implement `PartialEq`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0369]: binary operation `==` cannot be applied to type `(std::io::Error, Thread)`
    ╭▸ $DIR/binary-op-not-allowed-issue-125631.rs:11:9
    │
-LL │     (Error::new(ErrorKind::Other, "2"), thread::current())
+10 │     (Error::new(ErrorKind::Other, "2"), thread::current())
    │     ────────────────────────────────────────────────────── (std::io::Error, Thread)
-LL │         == (Error::new(ErrorKind::Other, "2"), thread::current());
+11 │         == (Error::new(ErrorKind::Other, "2"), thread::current());
    │         ━━ ────────────────────────────────────────────────────── (std::io::Error, Thread)
    ╰╴
 note: the foreign item types don't implement required traits for this operation to be valid
@@ -4057,32 +4044,32 @@ pub fn main() {}
 
     let expected_ascii = str![[r#"
 error: cannot find derive macro `Eqr` in this scope
-  --> $DIR/deriving-meta-unknown-trait.rs:1:10
-   |
-LL | #[derive(Eqr)]
-   |          ^^^ help: a derive macro with a similar name exists: `Eq`
-   |
-  --> $SRC_DIR/core/src/cmp.rs:356:0
-   |
-   = note: similarly named derive macro `Eq` defined here
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+ --> $DIR/deriving-meta-unknown-trait.rs:1:10
+  |
+1 | #[derive(Eqr)]
+  |          ^^^ help: a derive macro with a similar name exists: `Eq`
+  |
+ --> $SRC_DIR/core/src/cmp.rs:356:0
+  |
+  = note: similarly named derive macro `Eq` defined here
+  |
+  = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: cannot find derive macro `Eqr` in this scope
-   ╭▸ $DIR/deriving-meta-unknown-trait.rs:1:10
-   │
-LL │ #[derive(Eqr)]
-   │          ━━━ help: a derive macro with a similar name exists: `Eq`
-   ╰╴
-   ╭▸ $SRC_DIR/core/src/cmp.rs:356:0
-   │
-   ├ note: similarly named derive macro `Eq` defined here
-   │
-   ╰ note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+  ╭▸ $DIR/deriving-meta-unknown-trait.rs:1:10
+  │
+1 │ #[derive(Eqr)]
+  │          ━━━ help: a derive macro with a similar name exists: `Eq`
+  ╰╴
+  ╭▸ $SRC_DIR/core/src/cmp.rs:356:0
+  │
+  ├ note: similarly named derive macro `Eq` defined here
+  │
+  ╰ note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -4147,10 +4134,10 @@ which is required by `&mut Ipv4Addr: proc_macro::ext::RepIteratorExt`"#;
 error[E0599]: the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not satisfied
   --> $DIR/not-repeatable.rs:11:13
    |
-LL | struct Ipv4Addr;
+ 7 | struct Ipv4Addr;
    | --------------- method `quote_into_iter` not found for this struct because it doesn't satisfy `Ipv4Addr: Iterator`, `Ipv4Addr: ToTokens`, `Ipv4Addr: proc_macro::ext::RepIteratorExt` or `Ipv4Addr: proc_macro::ext::RepToTokensExt`
 ...
-LL |     let _ = quote! { $($ip)* }; //~ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not s...
+11 |     let _ = quote! { $($ip)* }; //~ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not s...
    |             ^^^^^^^^^^^^^^^^^^ method cannot be called on `Ipv4Addr` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
@@ -4166,17 +4153,17 @@ note: the traits `Iterator` and `ToTokens` must be implemented
   --> $SRC_DIR/proc_macro/src/to_tokens.rs:11:0
   --> $SRC_DIR/core/src/iter/traits/iterator.rs:39:0
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0599]: the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not satisfied
    ╭▸ $DIR/not-repeatable.rs:11:13
    │
-LL │ struct Ipv4Addr;
+ 7 │ struct Ipv4Addr;
    │ ─────────────── method `quote_into_iter` not found for this struct because it doesn't satisfy `Ipv4Addr: Iterator`, `Ipv4Addr: ToTokens`, `Ipv4Addr: proc_macro::ext::RepIteratorExt` or `Ipv4Addr: proc_macro::ext::RepToTokensExt`
    ‡
-LL │     let _ = quote! { $($ip)* }; //~ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not sat…
+11 │     let _ = quote! { $($ip)* }; //~ ERROR the method `quote_into_iter` exists for struct `Ipv4Addr`, but its trait bounds were not sat…
    │             ━━━━━━━━━━━━━━━━━━ method cannot be called on `Ipv4Addr` due to unsatisfied trait bounds
    │
    ╰ note: the following trait bounds were not satisfied:
@@ -4256,26 +4243,26 @@ fn main() {
 error[E0220]: associated type `Pr` not found for `S<bool>` in the current scope
   --> $DIR/not-found-self-type-differs-shadowing-trait-item.rs:28:23
    |
-LL | struct S<T>(T);
+12 | struct S<T>(T);
    | ----------- associated type `Pr` not found for this struct
 ...
-LL |     let _: S::<bool>::Pr = ();
+28 |     let _: S::<bool>::Pr = ();
    |                       ^^ associated item not found in `S<bool>`
    |
    = note: the associated type was found for
            
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0220]: associated type `Pr` not found for `S<bool>` in the current scope
    ╭▸ $DIR/not-found-self-type-differs-shadowing-trait-item.rs:28:23
    │
-LL │ struct S<T>(T);
+12 │ struct S<T>(T);
    │ ─────────── associated type `Pr` not found for this struct
    ‡
-LL │     let _: S::<bool>::Pr = ();
+28 │     let _: S::<bool>::Pr = ();
    │                       ━━ associated item not found in `S<bool>`
    │
    ╰ note: the associated type was found for
@@ -4341,16 +4328,16 @@ fn main() {}
 error: extern blocks should be unsafe
   --> $DIR/unsafe-extern-suggestion.rs:6:1
    |
-LL |   extern "C" {
+ 6 |   extern "C" {
    |   ^
    |   |
    |  _help: needs `unsafe` before the extern keyword: `unsafe`
    | |
-LL | |     //~^ ERROR extern blocks should be unsafe [missing_unsafe_on_extern]
-LL | |     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
-LL | |     static TEST1: i32;
-LL | |     fn test1(i: i32);
-LL | | }
+ 7 | |     //~^ ERROR extern blocks should be unsafe [missing_unsafe_on_extern]
+ 8 | |     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
+ 9 | |     static TEST1: i32;
+10 | |     fn test1(i: i32);
+11 | | }
    | |_^
    |
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
@@ -4358,26 +4345,26 @@ LL | | }
 note: the lint level is defined here
   --> $DIR/unsafe-extern-suggestion.rs:3:9
    |
-LL | #![deny(missing_unsafe_on_extern)]
+ 3 | #![deny(missing_unsafe_on_extern)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: extern blocks should be unsafe
    ╭▸ $DIR/unsafe-extern-suggestion.rs:6:1
    │
-LL │   extern "C" {
+ 6 │   extern "C" {
    │   ╿
    │   │
    │ ┏━help: needs `unsafe` before the extern keyword: `unsafe`
    │ ┃
-LL │ ┃     //~^ ERROR extern blocks should be unsafe [missing_unsafe_on_extern]
-LL │ ┃     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
-LL │ ┃     static TEST1: i32;
-LL │ ┃     fn test1(i: i32);
-LL │ ┃ }
+ 7 │ ┃     //~^ ERROR extern blocks should be unsafe [missing_unsafe_on_extern]
+ 8 │ ┃     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
+ 9 │ ┃     static TEST1: i32;
+10 │ ┃     fn test1(i: i32);
+11 │ ┃ }
    │ ┗━┛
    │
    ├ warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
@@ -4385,7 +4372,7 @@ LL │ ┃ }
 note: the lint level is defined here
    ╭▸ $DIR/unsafe-extern-suggestion.rs:3:9
    │
-LL │ #![deny(missing_unsafe_on_extern)]
+ 3 │ #![deny(missing_unsafe_on_extern)]
    ╰╴        ━━━━━━━━━━━━━━━━━━━━━━━━
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4468,14 +4455,14 @@ fn panic(_: &core::panic::PanicInfo) -> ! { loop {} }
 error[E0308]: mismatched types
   --> $DIR/alloc-error-handler-bad-signature-2.rs:10:1
    |
-LL |    #[alloc_error_handler]
+ 9 |    #[alloc_error_handler]
    |    ---------------------- in this procedural macro expansion
-LL | // fn oom(
-LL | ||     info: Layout, //~^ ERROR mismatched types
-LL | || ) { //~^^ ERROR mismatched types
+10 | // fn oom(
+11 | ||     info: Layout, //~^ ERROR mismatched types
+12 | || ) { //~^^ ERROR mismatched types
    | ||_- arguments to this function are incorrect
-LL | |      loop {}
-LL | |  }
+13 | |      loop {}
+14 | |  }
    | |__^ expected `Layout`, found `core::alloc::Layout`
    |
    = note: `core::alloc::Layout` and `Layout` have similar names, but are actually distinct types
@@ -4484,31 +4471,31 @@ note: `core::alloc::Layout` is defined in crate `core`
 note: `Layout` is defined in the current crate
   --> $DIR/alloc-error-handler-bad-signature-2.rs:7:1
    |
-LL | struct Layout;
+ 7 | struct Layout;
    | ^^^^^^^^^^^^^
 note: function defined here
   --> $DIR/alloc-error-handler-bad-signature-2.rs:10:4
    |
-LL | fn oom(
+10 | fn oom(
    |    ^^^
-LL |     info: Layout, //~^ ERROR mismatched types
+11 |     info: Layout, //~^ ERROR mismatched types
    |     ------------
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0308]: mismatched types
    ╭▸ $DIR/alloc-error-handler-bad-signature-2.rs:10:1
    │
-LL │    #[alloc_error_handler]
+ 9 │    #[alloc_error_handler]
    │    ────────────────────── in this procedural macro expansion
-LL │ ┏┌ fn oom(
-LL │ ┃│     info: Layout, //~^ ERROR mismatched types
-LL │ ┃│ ) { //~^^ ERROR mismatched types
+10 │ ┏┌ fn oom(
+11 │ ┃│     info: Layout, //~^ ERROR mismatched types
+12 │ ┃│ ) { //~^^ ERROR mismatched types
    │ ┃└─┘ arguments to this function are incorrect
-LL │ ┃      loop {}
-LL │ ┃  }
+13 │ ┃      loop {}
+14 │ ┃  }
    │ ┗━━┛ expected `Layout`, found `core::alloc::Layout`
    │
    ╰ note: `core::alloc::Layout` and `Layout` have similar names, but are actually distinct types
@@ -4517,14 +4504,14 @@ note: `core::alloc::Layout` is defined in crate `core`
 note: `Layout` is defined in the current crate
    ╭▸ $DIR/alloc-error-handler-bad-signature-2.rs:7:1
    │
-LL │ struct Layout;
+ 7 │ struct Layout;
    ╰╴━━━━━━━━━━━━━
 note: function defined here
    ╭▸ $DIR/alloc-error-handler-bad-signature-2.rs:10:4
    │
-LL │ fn oom(
+10 │ fn oom(
    │    ━━━
-LL │     info: Layout, //~^ ERROR mismatched types
+11 │     info: Layout, //~^ ERROR mismatched types
    ╰╴    ────────────
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4586,23 +4573,23 @@ fn main() {
 warning: whitespace symbol '\u{a0}' is not skipped
   --> $DIR/str-escape.rs:12:18
    |
-LL |       let s = c"foo\
+12 |       let s = c"foo\
    |  __________________^
-LL | |              bar
+13 | |              bar
    | |   ^ whitespace symbol '\u{a0}' is not skipped
    | |___|
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii.raw());
 
     let expected_unicode = str![[r#"
 warning: whitespace symbol '\u{a0}' is not skipped
    ╭▸ $DIR/str-escape.rs:12:18
    │
-LL │       let s = c"foo\
+12 │       let s = c"foo\
    │ ┏━━━━━━━━━━━━━━━━━━┛
-LL │ ┃              bar
+13 │ ┃              bar
    │ ┃   ╿ whitespace symbol '\u{a0}' is not skipped
    │ ┗━━━│
    ╰╴
@@ -4679,7 +4666,7 @@ fn main() {
 error[E0004]: non-exhaustive patterns: `Some(Private { misc: true, .. })` not covered
    ╭▸ $DIR/match-privately-empty.rs:14:11
    │
-LL │     match private::DATA {
+14 │     match private::DATA {
    │           ━━━━━━━━━━━━━ pattern `Some(Private { misc: true, .. })` not covered
    ╰╴
 note: `Option<Private>` defined here
@@ -4690,20 +4677,18 @@ note: `Option<Private>` defined here
    ╰ note: the matched value is of type `Option<Private>`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    ╭╴
-LL ±         Some(private::Private { misc: false, .. }) => {},
-LL +         Some(Private { misc: true, .. }) => todo!()
+33 ±         Some(private::Private { misc: false, .. }) => {},
+34 +         Some(Private { misc: true, .. }) => todo!()
    ╰╴
 "#]];
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .decor_style(DecorStyle::Unicode);
+    let renderer = Renderer::plain().decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0004]: non-exhaustive patterns: `Some(Private { misc: true, .. })` not covered
    ╭▸ $DIR/match-privately-empty.rs:14:11
    │
-LL │     match private::DATA {
+14 │     match private::DATA {
    │           ━━━━━━━━━━━━━ pattern `Some(Private { misc: true, .. })` not covered
    ╰╴
 note: `Option<Private>` defined here
@@ -4714,8 +4699,8 @@ note: `Option<Private>` defined here
    ╰ note: the matched value is of type `Option<Private>`
 help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
    ╭╴
-LL ±         Some(private::Private { misc: false, .. }) => {},
-LL +         Some(Private { misc: true, .. }) => todo!()
+33 ±         Some(private::Private { misc: false, .. }) => {},
+34 +         Some(Private { misc: true, .. }) => todo!()
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4791,7 +4776,7 @@ for more information, visit <https://doc.rust-lang.org/reference/items/traits.ht
 error[E0038]: the trait `Ord` is not dyn compatible
    ╭▸ $DIR/bare-trait-dont-suggest-dyn.rs:6:33
    │
-LL │ fn ord_prefer_dot(s: String) -> Ord {
+ 6 │ fn ord_prefer_dot(s: String) -> Ord {
    │                                 ━━━ `Ord` is not dyn compatible
    ╰╴
 note: for a trait to be dyn compatible it needs to allow building a vtable
@@ -4804,19 +4789,17 @@ note: for a trait to be dyn compatible it needs to allow building a vtable
    ╰ note: the trait is not dyn compatible because it uses `Self` as a type parameter
 help: consider using an opaque type instead
    ╭╴
-LL │ fn ord_prefer_dot(s: String) -> impl Ord {
+11 │ fn ord_prefer_dot(s: String) -> impl Ord {
    ╰╴                                ++++
 "#]];
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .decor_style(DecorStyle::Unicode);
+    let renderer = Renderer::plain().decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0038]: the trait `Ord` is not dyn compatible
    ╭▸ $DIR/bare-trait-dont-suggest-dyn.rs:6:33
    │
-LL │ fn ord_prefer_dot(s: String) -> Ord {
+ 6 │ fn ord_prefer_dot(s: String) -> Ord {
    │                                 ━━━ `Ord` is not dyn compatible
    ╰╴
 note: for a trait to be dyn compatible it needs to allow building a vtable
@@ -4829,7 +4812,7 @@ note: for a trait to be dyn compatible it needs to allow building a vtable
    ╰ note: the trait is not dyn compatible because it uses `Self` as a type parameter
 help: consider using an opaque type instead
    ╭╴
-LL │ fn ord_prefer_dot(s: String) -> impl Ord {
+11 │ fn ord_prefer_dot(s: String) -> impl Ord {
    ╰╴                                ++++
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -4902,9 +4885,9 @@ fn main() {
 error[E0369]: binary operation `==` cannot be applied to type `(std::io::Error, Thread)`
    ╭▸ $DIR/binary-op-not-allowed-issue-125631.rs:11:9
    │
-LL │     (Error::new(ErrorKind::Other, "2"), thread::current())
+10 │     (Error::new(ErrorKind::Other, "2"), thread::current())
    │     ────────────────────────────────────────────────────── (std::io::Error, Thread)
-LL │         == (Error::new(ErrorKind::Other, "2"), thread::current());
+11 │         == (Error::new(ErrorKind::Other, "2"), thread::current());
    │         ━━ ────────────────────────────────────────────────────── (std::io::Error, Thread)
    ╰╴
 note: the foreign item types don't implement required traits for this operation to be valid
@@ -4915,18 +4898,16 @@ note: the foreign item types don't implement required traits for this operation
    │
    ╰ note: not implement `PartialEq`
 "#]];
-    let renderer = Renderer::plain()
-        .anonymized_line_numbers(true)
-        .decor_style(DecorStyle::Unicode);
+    let renderer = Renderer::plain().decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0369]: binary operation `==` cannot be applied to type `(std::io::Error, Thread)`
    ╭▸ $DIR/binary-op-not-allowed-issue-125631.rs:11:9
    │
-LL │     (Error::new(ErrorKind::Other, "2"), thread::current())
+10 │     (Error::new(ErrorKind::Other, "2"), thread::current())
    │     ────────────────────────────────────────────────────── (std::io::Error, Thread)
-LL │         == (Error::new(ErrorKind::Other, "2"), thread::current());
+11 │         == (Error::new(ErrorKind::Other, "2"), thread::current());
    │         ━━ ────────────────────────────────────────────────────── (std::io::Error, Thread)
    ╰╴
 note: the foreign item types don't implement required traits for this operation to be valid
@@ -5030,40 +5011,40 @@ fn main() {}
 error[E0433]: failed to resolve: use of undeclared type `IntoIter`
   --> $DIR/issue-82956.rs:25:24
    |
-LL |         let mut iter = IntoIter::new(self);
+25 |         let mut iter = IntoIter::new(self);
    |                        ^^^^^^^^ use of undeclared type `IntoIter`
    |
 help: consider importing one of these structs
    |
-LL + use std::array::IntoIter;
+ 4 + use std::array::IntoIter;
    |
-LL + use std::collections::binary_heap::IntoIter;
+ 4 + use std::collections::binary_heap::IntoIter;
    |
-LL + use std::collections::btree_map::IntoIter;
+ 4 + use std::collections::btree_map::IntoIter;
    |
-LL + use std::collections::btree_set::IntoIter;
+ 4 + use std::collections::btree_set::IntoIter;
    |
    = and 9 other candidates
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0433]: failed to resolve: use of undeclared type `IntoIter`
    ╭▸ $DIR/issue-82956.rs:25:24
    │
-LL │         let mut iter = IntoIter::new(self);
+25 │         let mut iter = IntoIter::new(self);
    │                        ━━━━━━━━ use of undeclared type `IntoIter`
    ╰╴
 help: consider importing one of these structs
    ╭╴
-LL + use std::array::IntoIter;
+ 4 + use std::array::IntoIter;
    ├╴
-LL + use std::collections::binary_heap::IntoIter;
+ 4 + use std::collections::binary_heap::IntoIter;
    ├╴
-LL + use std::collections::btree_map::IntoIter;
+ 4 + use std::collections::btree_map::IntoIter;
    ├╴
-LL + use std::collections::btree_set::IntoIter;
+ 4 + use std::collections::btree_set::IntoIter;
    │
    ╰ and 9 other candidates
 "#]];
@@ -5157,7 +5138,7 @@ fn main() {
 error[E0423]: expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
   --> $DIR/multi-suggestion.rs:17:13
    |
-LL |     let _ = std::collections::HashMap();
+17 |     let _ = std::collections::HashMap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   ::: $SRC_DIR/std/src/collections/hash/map.rs:242:0
    |
@@ -5165,30 +5146,30 @@ LL |     let _ = std::collections::HashMap();
    |
 help: you might have meant to use an associated function to build this type
    |
-LL |     let _ = std::collections::HashMap::new();
+17 |     let _ = std::collections::HashMap::new();
    |                                      +++++
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_capacity(_);
    |
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_hasher(_);
    |
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
    |
 help: consider using the `Default` trait
    |
-LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
+17 |     let _ = <std::collections::HashMap as std::default::Default>::default();
    |             +                          ++++++++++++++++++++++++++++++++++
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0423]: expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
    ╭▸ $DIR/multi-suggestion.rs:17:13
    │
-LL │     let _ = std::collections::HashMap();
+17 │     let _ = std::collections::HashMap();
    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━
    ⸬  $SRC_DIR/std/src/collections/hash/map.rs:242:0
    │
@@ -5196,20 +5177,20 @@ LL │     let _ = std::collections::HashMap();
    ╰╴
 help: you might have meant to use an associated function to build this type
    ╭╴
-LL │     let _ = std::collections::HashMap::new();
+17 │     let _ = std::collections::HashMap::new();
    ├╴                                     +++++
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_capacity(_);
    ├╴
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_hasher(_);
    ├╴
-LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+17 -     let _ = std::collections::HashMap();
+17 +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
    ╰╴
 help: consider using the `Default` trait
    ╭╴
-LL │     let _ = <std::collections::HashMap as std::default::Default>::default();
+17 │     let _ = <std::collections::HashMap as std::default::Default>::default();
    ╰╴            +                          ++++++++++++++++++++++++++++++++++
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -5305,7 +5286,7 @@ fn main() {
 error[E0423]: cannot initialize a tuple struct which contains private fields
   --> $DIR/suggest-box-new.rs:11:19
    |
-LL |         wtf: Some(Box(U {
+11 |         wtf: Some(Box(U {
    |                   ^^^
    |
 note: constructor is not visible here due to private fields
@@ -5316,45 +5297,45 @@ note: constructor is not visible here due to private fields
    = note: private field
 help: you might have meant to use an associated function to build this type
    |
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new(_)),
-   |
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_uninit()),
-   |
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_zeroed()),
-   |
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_in(_, _)),
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new(_)),
+   |
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_uninit()),
+   |
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_zeroed()),
+   |
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_in(_, _)),
    |
    = and 12 other candidates
 help: consider using the `Default` trait
    |
-LL -         wtf: Some(Box(U {
-LL +         wtf: Some(<Box as std::default::Default>::default()),
+11 -         wtf: Some(Box(U {
+11 +         wtf: Some(<Box as std::default::Default>::default()),
    |
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0423]: cannot initialize a tuple struct which contains private fields
    ╭▸ $DIR/suggest-box-new.rs:11:19
    │
-LL │         wtf: Some(Box(U {
+11 │         wtf: Some(Box(U {
    │                   ━━━
    ╰╴
 note: constructor is not visible here due to private fields
@@ -5365,35 +5346,35 @@ note: constructor is not visible here due to private fields
    ╰ note: private field
 help: you might have meant to use an associated function to build this type
    ╭╴
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new(_)),
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new(_)),
    ├╴
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_uninit()),
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_uninit()),
    ├╴
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_zeroed()),
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_zeroed()),
    ├╴
-LL -         wtf: Some(Box(U {
-LL -             wtf: None,
-LL -             x: (),
-LL -         })),
-LL +         wtf: Some(Box::new_in(_, _)),
+11 -         wtf: Some(Box(U {
+12 -             wtf: None,
+13 -             x: (),
+14 -         })),
+11 +         wtf: Some(Box::new_in(_, _)),
    │
    ╰ and 12 other candidates
 help: consider using the `Default` trait
    ╭╴
-LL -         wtf: Some(Box(U {
-LL +         wtf: Some(<Box as std::default::Default>::default()),
+11 -         wtf: Some(Box(U {
+11 +         wtf: Some(<Box as std::default::Default>::default()),
    ╰╴
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
@@ -5481,46 +5462,46 @@ fn main() {}
 error[E0599]: no method named `bar` found for struct `Thing` in the current scope
   --> $DIR/too-many-field-suggestions.rs:25:7
    |
-LL | struct Thing {
+ 1 | struct Thing {
    | ------------ method `bar` not found for this struct
 ...
-LL |     t.bar();
+25 |     t.bar();
    |       ^^^ method not found in `Thing`
    |
 help: some of the expressions' fields have a method of the same name
    |
-LL |     t.a0.bar();
+25 |     t.a0.bar();
    |       +++
-LL |     t.a1.bar();
+25 |     t.a1.bar();
    |       +++
-LL |     t.a2.bar();
+25 |     t.a2.bar();
    |       +++
-LL |     t.a3.bar();
+25 |     t.a3.bar();
    |       +++
    = and 6 other candidates
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error[E0599]: no method named `bar` found for struct `Thing` in the current scope
    ╭▸ $DIR/too-many-field-suggestions.rs:25:7
    │
-LL │ struct Thing {
+ 1 │ struct Thing {
    │ ──────────── method `bar` not found for this struct
    ‡
-LL │     t.bar();
+25 │     t.bar();
    │       ━━━ method not found in `Thing`
    ╰╴
 help: some of the expressions' fields have a method of the same name
    ╭╴
-LL │     t.a0.bar();
+25 │     t.a0.bar();
    ├╴      +++
-LL │     t.a1.bar();
+25 │     t.a1.bar();
    ├╴      +++
-LL │     t.a2.bar();
+25 │     t.a2.bar();
    ├╴      +++
-LL │     t.a3.bar();
+25 │     t.a3.bar();
    │       +++
    ╰ and 6 other candidates
 "#]];
@@ -5542,18 +5523,18 @@ fn invalid_arguments_unterminated() {
         ))];
     let expected_ascii = str![[r#"
 error: invalid `--check-cfg` argument: `cfg(`
-   |
-   = note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
-   = note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
+  |
+  = note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
+  = note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: invalid `--check-cfg` argument: `cfg(`
-   │
-   ├ note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
-   ╰ note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
+  │
+  ├ note: expected `cfg(name, values("value1", "value2", ... "valueN"))`
+  ╰ note: visit <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more details
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);
@@ -5616,32 +5597,32 @@ If your compilation actually takes a long time, you can safely allow the lint.";
     ];
     let expected_ascii = str![[r#"
 error: constant evaluation is taking a long time
-  --> $SRC_DIR/core/src/num/mod.rs:1151:4
-   = note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
-           If your compilation actually takes a long time, you can safely allow the lint.
+ --> $SRC_DIR/core/src/num/mod.rs:1151:4
+  = note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
+          If your compilation actually takes a long time, you can safely allow the lint.
 help: the constant being evaluated
-  --> $DIR/timeout.rs:7:1
-   |
-LL | static ROOK_ATTACKS_TABLE: () = {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: `#[deny(long_running_const_eval)]` on by default
-   = note: this error originates in the macro `uint_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+ --> $DIR/timeout.rs:7:1
+  |
+7 | static ROOK_ATTACKS_TABLE: () = {
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  = note: `#[deny(long_running_const_eval)]` on by default
+  = note: this error originates in the macro `uint_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 "#]];
-    let renderer = Renderer::plain().anonymized_line_numbers(true);
+    let renderer = Renderer::plain();
     assert_data_eq!(renderer.render(input), expected_ascii);
 
     let expected_unicode = str![[r#"
 error: constant evaluation is taking a long time
-   ╭▸ $SRC_DIR/core/src/num/mod.rs:1151:4
-   ╰ note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
-           If your compilation actually takes a long time, you can safely allow the lint.
+  ╭▸ $SRC_DIR/core/src/num/mod.rs:1151:4
+  ╰ note: this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval.
+          If your compilation actually takes a long time, you can safely allow the lint.
 help: the constant being evaluated
-   ╭▸ $DIR/timeout.rs:7:1
-   │
-LL │ static ROOK_ATTACKS_TABLE: () = {
-   │ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-   ├ note: `#[deny(long_running_const_eval)]` on by default
-   ╰ note: this error originates in the macro `uint_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
+  ╭▸ $DIR/timeout.rs:7:1
+  │
+7 │ static ROOK_ATTACKS_TABLE: () = {
+  │ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ├ note: `#[deny(long_running_const_eval)]` on by default
+  ╰ note: this error originates in the macro `uint_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 "#]];
     let renderer = renderer.decor_style(DecorStyle::Unicode);
     assert_data_eq!(renderer.render(input), expected_unicode);