Merge pull request #24853 from zeertzjq/inline-virt-eol

fix(ui): wrong cursor position with left gravity inline virt text at eol

6 files changed, 241 insertions, 137 deletions

diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 31ca9b16ce..7e92128b65 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -868,8 +868,8 @@ static void apply_cursorline_highlight(win_T *wp, winlinevars_T *wlv)
   }
 }
 
-// Checks if there is more inline virtual text that need to be drawn
-// and sets has_more_virt_inline_chunks to reflect that.
+/// Checks if there is more inline virtual text that need to be drawn
+/// and sets has_more_virt_inline_chunks to reflect that.
 static bool has_more_inline_virt(winlinevars_T *wlv, ptrdiff_t v)
 {
   DecorState *state = &decor_state;
@@ -3096,8 +3096,8 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool number_onl
             || wlv.filler_todo > 0
             || (wp->w_p_list && wp->w_p_lcs_chars.eol != NUL
                 && wlv.p_extra != at_end_str)
-            || (wlv.n_extra != 0
-                && (wlv.c_extra != NUL || *wlv.p_extra != NUL)) || wlv.more_virt_inline_chunks)) {
+            || (wlv.n_extra != 0 && (wlv.c_extra != NUL || *wlv.p_extra != NUL))
+            || wlv.more_virt_inline_chunks)) {
       bool wrap = wp->w_p_wrap       // Wrapping enabled.
                   && wlv.filler_todo <= 0          // Not drawing diff filler lines.
                   && lcs_eol_one != -1         // Haven't printed the lcs_eol character.
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 0077dc3102..3978539df6 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -862,15 +862,6 @@ void curs_columns(win_T *wp, int may_scroll)
       n = (wp->w_wcol - wp->w_width_inner) / width2 + 1;
       wp->w_wcol -= n * width2;
       wp->w_wrow += n;
-
-      // When cursor wraps to first char of next line in Insert
-      // mode, the 'showbreak' string isn't shown, backup to first
-      // column
-      char *const sbr = get_showbreak_value(wp);
-      if (*sbr && *get_cursor_pos_ptr() == NUL
-          && wp->w_wcol == (wp->w_width_inner - width2) + vim_strsize(sbr)) {
-        wp->w_wcol = 0;
-      }
     }
   } else if (may_scroll
              && !wp->w_cline_folded) {
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index c95f362518..b95adc1415 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -359,7 +359,7 @@ int win_lbr_chartabsize(chartabsize_T *cts, int *headp)
         if (width <= 0) {
           width = 1;
         }
-        // divide "size - prev_width" by "width", rounding up
+        // Divide "size - prev_rem" by "width", rounding up.
         int cnt = (size - prev_rem + width - 1) / width;
         added += cnt * head_mid;
 
@@ -371,7 +371,11 @@ int win_lbr_chartabsize(chartabsize_T *cts, int *headp)
         } else if (max_head_vcol < 0) {
           int off = virt_text_cursor_off(cts, c == NUL);
           if (off >= prev_rem) {
-            head += (1 + (off - prev_rem) / width) * head_mid;
+            if (size > off) {
+              head += (1 + (off - prev_rem) / width) * head_mid;
+            } else {
+              head += (off - prev_rem + width - 1) / width * head_mid;
+            }
           }
         }
       }
diff --git a/test/functional/legacy/breakindent_spec.lua b/test/functional/legacy/breakindent_spec.lua
index ecd2d47f47..3913ba935a 100644
--- a/test/functional/legacy/breakindent_spec.lua
+++ b/test/functional/legacy/breakindent_spec.lua
@@ -21,7 +21,6 @@ describe('breakindent', function()
       set listchars=eol:$
       let &signcolumn = 'yes'
       let &showbreak = '++'
-      let &breakindent = v:true
       let &breakindentopt = 'shift:2'
       let leftcol = win_getid()->getwininfo()->get(0, {})->get('textoff')
       eval repeat('x', &columns - leftcol - 1)->setline(1)
@@ -39,6 +38,9 @@ describe('breakindent', function()
     -- No line wraps, so changing 'showbreak' should lead to the same screen.
     command('setlocal showbreak=+')
     screen:expect_unchanged()
+    -- No line wraps, so setting 'breakindent' should lead to the same screen.
+    command('setlocal breakindent')
+    screen:expect_unchanged()
     -- The first line now wraps because of "eol" in 'listchars'.
     command('setlocal list')
     screen:expect{grid=[[
@@ -49,5 +51,14 @@ describe('breakindent', function()
       {0:~                                                                          }|
       {2:-- INSERT --}                                                               |
     ]]}
+    command('setlocal nobreakindent')
+    screen:expect{grid=[[
+      {1:  }xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxX|
+      {1:  }{0:+^$}                                                                       |
+      {1:  }second line{0:$}                                                             |
+      {0:~                                                                          }|
+      {0:~                                                                          }|
+      {2:-- INSERT --}                                                               |
+    ]]}
   end)
 end)
diff --git a/test/functional/ui/decorations_spec.lua b/test/functional/ui/decorations_spec.lua
index 0dd8fd8ad9..63f8c1e82c 100644
--- a/test/functional/ui/decorations_spec.lua
+++ b/test/functional/ui/decorations_spec.lua
@@ -1976,91 +1976,100 @@ describe('decorations: inline virtual text', function()
   end)
 
   it('text is drawn correctly with a wrapping virtual text', function()
-    screen:try_resize(50, 8)
-    feed('o<esc>')
-    insert([[aaaaaaa
-
-bbbbbbb]])
-    meths.buf_set_extmark(0, ns, 0, 0, { virt_text = { { string.rep('X', 51), 'Special' } }, virt_text_pos = 'inline' })
-    meths.buf_set_extmark(0, ns, 2, 0, { virt_text = { { string.rep('X', 50), 'Special' } }, virt_text_pos = 'inline' })
-    feed('gg0')
+    screen:try_resize(60, 8)
+    exec([[
+      call setline(1, ['', 'aaa', '', 'bbbbbb'])
+      normal gg0
+    ]])
+    meths.buf_set_extmark(0, ns, 0, 0, { virt_text = { { string.rep('X', 60), 'Special' } }, virt_text_pos = 'inline' })
+    meths.buf_set_extmark(0, ns, 2, 0, { virt_text = { { string.rep('X', 61), 'Special' } }, virt_text_pos = 'inline' })
+    feed('$')
     screen:expect{grid=[[
-      {10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      {10:X}                                                 |
-      aaaaaaa                                           |
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      bbbbbbb                                           |
-      {1:~                                                 }|
-      {1:~                                                 }|
-                                                        |
-      ]]}
-
+      {10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      aaa                                                         |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+                                                                  |
+    ]]}
     feed('j')
     screen:expect{grid=[[
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      {10:X}                                                 |
-      ^aaaaaaa                                           |
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      bbbbbbb                                           |
-      {1:~                                                 }|
-      {1:~                                                 }|
-                                                        |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      aa^a                                                         |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+                                                                  |
     ]]}
-
     feed('j')
     screen:expect{grid=[[
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      {10:X}                                                 |
-      aaaaaaa                                           |
-      {10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      bbbbbbb                                           |
-      {1:~                                                 }|
-      {1:~                                                 }|
-                                                        |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      aaa                                                         |
+      {10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+                                                                  |
     ]]}
-
     feed('j')
     screen:expect{grid=[[
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      {10:X}                                                 |
-      aaaaaaa                                           |
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      ^bbbbbbb                                           |
-      {1:~                                                 }|
-      {1:~                                                 }|
-                                                        |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      aaa                                                         |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      bbbbb^b                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+                                                                  |
     ]]}
-
-    feed('ggic')
+    feed('0<C-V>2l2k')
     screen:expect{grid=[[
-      c{10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      {10:XX}                                                |
-      aaaaaaa                                           |
-      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
-      bbbbbbb                                           |
-      {1:~                                                 }|
-      {1:~                                                 }|
-      {8:-- INSERT --}                                      |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {7:aa}^a                                                         |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      {7:bbb}bbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+      {8:-- VISUAL BLOCK --}                                          |
     ]]}
-  end)
-
-  it('regexp \\%V does not count trailing virtual text', function()
-    screen:try_resize(50, 4)
-    meths.buf_set_lines(0, 0, -1, true, {'foofoo', '', 'foofoo'})
-    meths.buf_set_extmark(0, ns, 1, 0, { virt_text = {{'barbarbar', 'Special'}}, virt_text_pos = 'inline' })
-    feed([[<C-V>G5l<Esc>/foo\n\%V<CR>]])
+    feed([[<Esc>/aaa\n\%V<CR>]])
     screen:expect{grid=[[
-      foo{12:^foo }                                           |
-      {10:barbarbar}                                         |
-      foofoo                                            |
-      {16:search hit BOTTOM, continuing at TOP}              |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {12:^aaa }                                                        |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:X}                                                           |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+      {16:search hit BOTTOM, continuing at TOP}                        |
+    ]]}
+    feed('3ggic')
+    screen:expect{grid=[[
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {12:aaa }                                                        |
+      c{10:^XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:XX}                                                          |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+      {8:-- INSERT --}                                                |
     ]]}
-    feed([[jIbaz<Esc>/foo\nbaz\%V<CR>]])
+    feed([[<Esc>/aaa\nc\%V<CR>]])
     screen:expect{grid=[[
-      foo{12:^foo }                                           |
-      {12:baz}{10:barbarbar}                                      |
-      foofoo                                            |
-      {16:search hit BOTTOM, continuing at TOP}              |
+      {10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {12:^aaa }                                                        |
+      {12:c}{10:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}|
+      {10:XX}                                                          |
+      bbbbbb                                                      |
+      {1:~                                                           }|
+      {1:~                                                           }|
+      {16:search hit BOTTOM, continuing at TOP}                        |
     ]]}
   end)
 
@@ -2209,111 +2218,119 @@ bbbbbbb]])
   end)
 
   it('cursor position is correct when inserting around a virtual text with left gravity', function()
-    insert('foo foo foo foo')
-    meths.buf_set_extmark(0, ns, 0, 8, { virt_text = { { 'virtual text', 'Special' } }, virt_text_pos = 'inline', right_gravity = false })
-    feed('0')
-    feed('8l')
+    screen:try_resize(27, 4)
+    insert(('a'):rep(15))
+    meths.buf_set_extmark(0, ns, 0, 8, { virt_text = { { ('>'):rep(43), 'Special' } }, virt_text_pos = 'inline', right_gravity = false })
+    command('setlocal showbreak=+ breakindent breakindentopt=shift:2')
+    feed('08l')
     screen:expect{grid=[[
-      foo foo {10:virtual text}^foo foo                       |
-      {1:~                                                 }|
-                                                        |
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}^aaaaaaa                 |
+                                 |
     ]]}
-
     feed('i')
     screen:expect{grid=[[
-      foo foo {10:virtual text}^foo foo                       |
-      {1:~                                                 }|
-      {8:-- INSERT --}                                      |
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}^aaaaaaa                 |
+      {8:-- INSERT --}               |
     ]]}
-
     feed([[<C-\><C-O>]])
     screen:expect{grid=[[
-      foo foo {10:virtual text}^foo foo                       |
-      {1:~                                                 }|
-      {8:-- (insert) --}                                    |
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}^aaaaaaa                 |
+      {8:-- (insert) --}             |
     ]]}
-
     feed('D')
     screen:expect{grid=[[
-      foo foo {10:virtual text}^                              |
-      {1:~                                                 }|
-      {8:-- INSERT --}                                      |
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>>>>>>>>>}|
+      {1:^~                          }|
+      {8:-- INSERT --}               |
+    ]]}
+    command('setlocal list listchars=eol:$')
+    screen:expect{grid=[[
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+^$}                       |
+      {8:-- INSERT --}               |
     ]]}
-
     feed('<C-U>')
     screen:expect{grid=[[
-      {10:virtual text}^                                      |
-      {1:~                                                 }|
-      {8:-- INSERT --}                                      |
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>}{1:^$}       |
+      {1:~                          }|
+      {8:-- INSERT --}               |
     ]]}
-
     feed('a')
     screen:expect{grid=[[
-      {10:virtual text}a^                                     |
-      {1:~                                                 }|
-      {8:-- INSERT --}                                      |
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>}a{1:^$}      |
+      {1:~                          }|
+      {8:-- INSERT --}               |
     ]]}
-
     feed('<Esc>')
     screen:expect{grid=[[
-      {10:virtual text}^a                                     |
-      {1:~                                                 }|
-                                                        |
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>}^a{1:$}      |
+      {1:~                          }|
+                                 |
     ]]}
-
     feed('x')
     screen:expect{grid=[[
-      {10:^virtual text}                                      |
-      {1:~                                                 }|
-                                                        |
+      {10:^>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>>>>>>>>>>>>>>>}{1:$}       |
+      {1:~                          }|
+                                 |
     ]]}
   end)
 
   it('cursor position is correct when inserting around virtual texts with both left and right gravity', function()
     screen:try_resize(30, 4)
     command('setlocal showbreak=+ breakindent breakindentopt=shift:2')
-    insert('foo foo foo foo')
+    insert(('a'):rep(15))
     meths.buf_set_extmark(0, ns, 0, 8, { virt_text = {{ ('>'):rep(32), 'Special' }}, virt_text_pos = 'inline', right_gravity = false })
     meths.buf_set_extmark(0, ns, 0, 8, { virt_text = {{ ('<'):rep(32), 'Special' }}, virt_text_pos = 'inline', right_gravity = true })
-
     feed('08l')
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>><<<<<<<<<<<<<<<<<}|
-        {1:+}{10:<<<<<<<<<<<<<<<}^foo foo     |
+        {1:+}{10:<<<<<<<<<<<<<<<}^aaaaaaa     |
                                     |
     ]]}
     feed('i')
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>>^<<<<<<<<<<<<<<<<<}|
-        {1:+}{10:<<<<<<<<<<<<<<<}foo foo     |
+        {1:+}{10:<<<<<<<<<<<<<<<}aaaaaaa     |
       {8:-- INSERT --}                  |
     ]]}
     feed('a')
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>>}a{10:^<<<<<<<<<<<<<<<<}|
-        {1:+}{10:<<<<<<<<<<<<<<<<}foo foo    |
+        {1:+}{10:<<<<<<<<<<<<<<<<}aaaaaaa    |
       {8:-- INSERT --}                  |
     ]]}
     feed([[<C-\><C-O>]])
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>>}a{10:<<<<<<<<<<<<<<<<}|
-        {1:+}{10:<<<<<<<<<<<<<<<<}^foo foo    |
+        {1:+}{10:<<<<<<<<<<<<<<<<}^aaaaaaa    |
       {8:-- (insert) --}                |
     ]]}
     feed('D')
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>>}a{10:^<<<<<<<<<<<<<<<<}|
         {1:+}{10:<<<<<<<<<<<<<<<<}           |
       {8:-- INSERT --}                  |
     ]]}
     feed('<BS>')
     screen:expect{grid=[[
-      foo foo {10:>>>>>>>>>>>>>>>>>>>>>>}|
+      aaaaaaaa{10:>>>>>>>>>>>>>>>>>>>>>>}|
         {1:+}{10:>>>>>>>>>>^<<<<<<<<<<<<<<<<<}|
         {1:+}{10:<<<<<<<<<<<<<<<}            |
       {8:-- INSERT --}                  |
@@ -2346,6 +2363,27 @@ bbbbbbb]])
         {1:+}{10:<<<<<<<}                    |
                                     |
     ]]}
+    feed('i')
+    screen:expect{grid=[[
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:>>^<<<<<<<<<<<<<<<<<<<<<<<<<}|
+        {1:+}{10:<<<<<<<}                    |
+      {8:-- INSERT --}                  |
+    ]]}
+    screen:try_resize(32, 4)
+    screen:expect{grid=[[
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+        {1:+}{10:^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<}|
+        {1:+}{10:<<<}                          |
+      {8:-- INSERT --}                    |
+    ]]}
+    command('setlocal nobreakindent')
+    screen:expect{grid=[[
+      {10:>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>}|
+      {1:+}{10:^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<}|
+      {1:+}{10:<}                              |
+      {8:-- INSERT --}                    |
+    ]]}
   end)
 
   it('draws correctly with no wrap multiple virtual text, where one is hidden', function()
@@ -2639,7 +2677,45 @@ bbbbbbb]])
     ]]}
   end)
 
-  it('list "extends" is drawn with only inline virtual text offscreen', function()
+  it('lcs-extends is drawn with inline virtual text at end of screen line', function()
+    exec([[
+      setlocal nowrap list listchars=extends:!
+      call setline(1, repeat('a', 51))
+    ]])
+    meths.buf_set_extmark(0, ns, 0, 50, { virt_text = { { 'bbb', 'Special' } }, virt_text_pos = 'inline' })
+    feed('20l')
+    screen:expect{grid=[[
+      aaaaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaa{1:!}|
+      {1:~                                                 }|
+                                                        |
+    ]]}
+    feed('zl')
+    screen:expect{grid=[[
+      aaaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{1:!}|
+      {1:~                                                 }|
+                                                        |
+    ]]}
+    feed('zl')
+    screen:expect{grid=[[
+      aaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{10:b}{1:!}|
+      {1:~                                                 }|
+                                                        |
+    ]]}
+    feed('zl')
+    screen:expect{grid=[[
+      aaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{10:bb}{1:!}|
+      {1:~                                                 }|
+                                                        |
+    ]]}
+    feed('zl')
+    screen:expect{grid=[[
+      aaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{10:bbb}a|
+      {1:~                                                 }|
+                                                        |
+    ]]}
+  end)
+
+  it('lcs-extends is drawn with only inline virtual text offscreen', function()
     command('set nowrap')
     command('set list')
     command('set listchars+=extends:c')
@@ -2797,9 +2873,9 @@ bbbbbbb]])
     screen:try_resize(30, 6)
     exec([[
       highlight! link LineNr Normal
-      call setline(1, repeat('a', 28))
       setlocal number showbreak=+ breakindent breakindentopt=shift:2
       setlocal scrolloff=0 smoothscroll
+      call setline(1, repeat('a', 28))
       normal! $
     ]])
     meths.buf_set_extmark(0, ns, 0, 27, { virt_text = { { ('123'):rep(23) } }, virt_text_pos = 'inline' })
@@ -3002,6 +3078,24 @@ bbbbbbb]])
       {1:~                             }|
                                     |
     ]]}
+    feed('26ia<Esc>a')
+    screen:expect{grid=[[
+        1 aaaaaaaaaaaaaaaaaaaaaaaaaa|
+            {1:+}^12312312312312312312312|
+            {1:+}31231231231231231231231|
+            {1:+}23123123123123123123123|
+      {1:~                             }|
+      {8:-- INSERT --}                  |
+    ]]}
+    feed([[<C-\><C-O>:setlocal breakindentopt=<CR>]])
+    screen:expect{grid=[[
+        1 aaaaaaaaaaaaaaaaaaaaaaaaaa|
+          {1:+}^1231231231231231231231231|
+          {1:+}2312312312312312312312312|
+          {1:+}3123123123123123123      |
+      {1:~                             }|
+      {8:-- INSERT --}                  |
+    ]]}
   end
 
   describe('with showbreak, smoothscroll', function()
@@ -3019,8 +3113,8 @@ bbbbbbb]])
   it('before TABs with smoothscroll', function()
     screen:try_resize(30, 6)
     exec([[
-      call setline(1, repeat("\t", 4) .. 'a')
       setlocal list listchars=tab:<-> scrolloff=0 smoothscroll
+      call setline(1, repeat("\t", 4) .. 'a')
       normal! $
     ]])
     meths.buf_set_extmark(0, ns, 0, 3, { virt_text = { { ('12'):rep(32) } }, virt_text_pos = 'inline' })
diff --git a/test/old/testdir/test_breakindent.vim b/test/old/testdir/test_breakindent.vim
index 3ce7d1386b..301e2d0e40 100644
--- a/test/old/testdir/test_breakindent.vim
+++ b/test/old/testdir/test_breakindent.vim
@@ -938,7 +938,6 @@ func Test_cursor_position_with_showbreak()
       vim9script
       &signcolumn = 'yes'
       &showbreak = '++'
-      &breakindent = true
       &breakindentopt = 'shift:2'
       var leftcol: number = win_getid()->getwininfo()->get(0, {})->get('textoff')
       repeat('x', &columns - leftcol - 1)->setline(1)
@@ -952,9 +951,14 @@ func Test_cursor_position_with_showbreak()
   " No line wraps, so changing 'showbreak' should lead to the same screen.
   call term_sendkeys(buf, "\<C-\>\<C-O>:setlocal showbreak=+\<CR>")
   call VerifyScreenDump(buf, 'Test_cursor_position_with_showbreak_1', {})
+  " No line wraps, so setting 'breakindent' should lead to the same screen.
+  call term_sendkeys(buf, "\<C-\>\<C-O>:setlocal breakindent\<CR>")
+  call VerifyScreenDump(buf, 'Test_cursor_position_with_showbreak_1', {})
   " The first line now wraps because of "eol" in 'listchars'.
   call term_sendkeys(buf, "\<C-\>\<C-O>:setlocal list\<CR>")
   call VerifyScreenDump(buf, 'Test_cursor_position_with_showbreak_2', {})
+  call term_sendkeys(buf, "\<C-\>\<C-O>:setlocal nobreakindent\<CR>")
+  call VerifyScreenDump(buf, 'Test_cursor_position_with_showbreak_3', {})
 
   call StopVimInTerminal(buf)
 endfunc