Merge pull request #15465 from dundargoc/refactor/uncrustify

refactor(codebase): Update uncrustify config and apply it on one file screen.c

The plan is to go through the codebase in batches, and remove the most egregious "make lint"
backlog failures, by applying this config.

1 files changed, 425 insertions, 369 deletions

diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 580f591b11..3675591bbc 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -65,46 +65,50 @@
 #include <stdbool.h>
 #include <string.h>
 
-#include "nvim/log.h"
-#include "nvim/vim.h"
-#include "nvim/ascii.h"
+#include "nvim/api/private/helpers.h"
+#include "nvim/api/vim.h"
 #include "nvim/arabic.h"
-#include "nvim/screen.h"
+#include "nvim/ascii.h"
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/cursor_shape.h"
+#include "nvim/decoration.h"
 #include "nvim/diff.h"
+#include "nvim/edit.h"
 #include "nvim/eval.h"
 #include "nvim/ex_cmds.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_getln.h"
-#include "nvim/edit.h"
+#include "nvim/extmark.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
-#include "nvim/indent.h"
+#include "nvim/garray.h"
 #include "nvim/getchar.h"
 #include "nvim/highlight.h"
+#include "nvim/indent.h"
+#include "nvim/lib/kvec.h"
+#include "nvim/log.h"
+#include "nvim/lua/executor.h"
 #include "nvim/main.h"
 #include "nvim/mark.h"
-#include "nvim/extmark.h"
-#include "nvim/decoration.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
 #include "nvim/memory.h"
 #include "nvim/menu.h"
 #include "nvim/message.h"
 #include "nvim/misc1.h"
-#include "nvim/garray.h"
 #include "nvim/move.h"
 #include "nvim/normal.h"
 #include "nvim/option.h"
+#include "nvim/os/time.h"
 #include "nvim/os_unix.h"
 #include "nvim/path.h"
 #include "nvim/plines.h"
 #include "nvim/popupmnu.h"
 #include "nvim/quickfix.h"
 #include "nvim/regexp.h"
+#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/sign.h"
 #include "nvim/spell.h"
@@ -116,12 +120,8 @@
 #include "nvim/ui_compositor.h"
 #include "nvim/undo.h"
 #include "nvim/version.h"
+#include "nvim/vim.h"
 #include "nvim/window.h"
-#include "nvim/os/time.h"
-#include "nvim/api/private/helpers.h"
-#include "nvim/api/vim.h"
-#include "nvim/lua/executor.h"
-#include "nvim/lib/kvec.h"
 
 #define MB_FILLER_CHAR '<'  /* character used when a double-width character
                              * doesn't fit. */
@@ -168,8 +168,7 @@ static bool resizing = false;
 
 static char * provider_err = NULL;
 
-static bool provider_invoke(NS ns_id, const char *name, LuaRef ref,
-                            Array args, bool default_true)
+static bool provider_invoke(NS ns_id, const char *name, LuaRef ref, Array args, bool default_true)
 {
   Error err = ERROR_INIT;
 
@@ -208,10 +207,12 @@ void redraw_later(win_T *wp, int type)
 {
   if (!exiting && wp->w_redr_type < type) {
     wp->w_redr_type = type;
-    if (type >= NOT_VALID)
+    if (type >= NOT_VALID) {
       wp->w_lines_valid = 0;
-    if (must_redraw < type)     /* must_redraw is the maximum of all windows */
+    }
+    if (must_redraw < type) {   /* must_redraw is the maximum of all windows */
       must_redraw = type;
+    }
   }
 }
 
@@ -270,10 +271,10 @@ void redraw_buf_range_later(buf_T *buf,  linenr_T firstline, linenr_T lastline)
     if (wp->w_buffer == buf
         && lastline >= wp->w_topline && firstline < wp->w_botline) {
       if (wp->w_redraw_top == 0 || wp->w_redraw_top > firstline) {
-          wp->w_redraw_top = firstline;
+        wp->w_redraw_top = firstline;
       }
       if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lastline) {
-          wp->w_redraw_bot = lastline;
+        wp->w_redraw_bot = lastline;
       }
       redraw_later(wp, VALID);
     }
@@ -288,20 +289,16 @@ void redraw_buf_range_later(buf_T *buf,  linenr_T firstline, linenr_T lastline)
  * Note that when also inserting/deleting lines w_redraw_top and w_redraw_bot
  * may become invalid and the whole window will have to be redrawn.
  */
-void
-redrawWinline(
-    win_T *wp,
-    linenr_T lnum
-)
+void redrawWinline(win_T *wp, linenr_T lnum)
   FUNC_ATTR_NONNULL_ALL
 {
   if (lnum >= wp->w_topline
       && lnum < wp->w_botline) {
     if (wp->w_redraw_top == 0 || wp->w_redraw_top > lnum) {
-        wp->w_redraw_top = lnum;
+      wp->w_redraw_top = lnum;
     }
     if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum) {
-        wp->w_redraw_bot = lnum;
+      wp->w_redraw_bot = lnum;
     }
     redraw_later(wp, VALID);
   }
@@ -339,8 +336,9 @@ int update_screen(int type)
   }
 
   if (must_redraw) {
-    if (type < must_redraw)         /* use maximal type */
+    if (type < must_redraw) {       /* use maximal type */
       type = must_redraw;
+    }
 
     /* must_redraw is reset here, so that when we run into some weird
     * reason to redraw while busy redrawing (e.g., asynchronous
@@ -350,8 +348,9 @@ int update_screen(int type)
   }
 
   /* Need to update w_lines[]. */
-  if (curwin->w_lines_valid == 0 && type < NOT_VALID)
+  if (curwin->w_lines_valid == 0 && type < NOT_VALID) {
     type = NOT_VALID;
+  }
 
   /* Postpone the redrawing when it's not needed and when being called
    * recursively. */
@@ -452,8 +451,9 @@ int update_screen(int type)
   compute_cmdrow();
 
   /* Check for changed highlighting */
-  if (need_highlight_changed)
+  if (need_highlight_changed) {
     highlight_changed();
+  }
 
   if (type == CLEAR) {          // first clear screen
     screenclear();              // will reset clear_cmdline
@@ -503,21 +503,24 @@ int update_screen(int type)
     redraw_tabline = true;
   }
 
-  if (clear_cmdline)            /* going to clear cmdline (done below) */
+  if (clear_cmdline) {          /* going to clear cmdline (done below) */
     check_for_delay(FALSE);
+  }
 
   /* Force redraw when width of 'number' or 'relativenumber' column
    * changes. */
   if (curwin->w_redr_type < NOT_VALID
       && curwin->w_nrwidth != ((curwin->w_p_nu || curwin->w_p_rnu)
-                               ? number_width(curwin) : 0))
+                               ? number_width(curwin) : 0)) {
     curwin->w_redr_type = NOT_VALID;
+  }
 
   /*
    * Only start redrawing if there is really something to do.
    */
-  if (type == INVERTED)
+  if (type == INVERTED) {
     update_curswant();
+  }
   if (curwin->w_redr_type < type
       && !((type == VALID
             && curwin->w_lines[0].wl_valid
@@ -530,8 +533,9 @@ int update_screen(int type)
                && curwin->w_old_visual_mode == VIsual_mode
                && (curwin->w_valid & VALID_VIRTCOL)
                && curwin->w_old_curswant == curwin->w_curswant)
-           ))
+           )) {
     curwin->w_redr_type = type;
+  }
 
   // Redraw the tab pages line if needed.
   if (redraw_tabline || type >= NOT_VALID) {
@@ -632,8 +636,9 @@ int update_screen(int type)
   }
 
   /* May put up an introductory message when not editing a file */
-  if (!did_intro)
+  if (!did_intro) {
     maybe_intro_message();
+  }
   did_intro = true;
 
   for (size_t i = 0; i < kv_size(providers); i++) {
@@ -704,7 +709,7 @@ bool win_cursorline_standout(const win_T *wp)
   FUNC_ATTR_NONNULL_ALL
 {
   return wp->w_p_cul
-    || (wp->w_p_cole > 0 && (VIsual_active || !conceal_cursor_line(wp)));
+         || (wp->w_p_cole > 0 && (VIsual_active || !conceal_cursor_line(wp)));
 }
 
 /*
@@ -715,22 +720,22 @@ bool win_cursorline_standout(const win_T *wp)
  *
  * How the window is redrawn depends on wp->w_redr_type.  Each type also
  * implies the one below it.
- * NOT_VALID	redraw the whole window
- * SOME_VALID	redraw the whole window but do scroll when possible
- * REDRAW_TOP	redraw the top w_upd_rows window lines, otherwise like VALID
- * INVERTED	redraw the changed part of the Visual area
- * INVERTED_ALL	redraw the whole Visual area
- * VALID	1. scroll up/down to adjust for a changed w_topline
- *		2. update lines at the top when scrolled down
- *		3. redraw changed text:
- *		   - if wp->w_buffer->b_mod_set set, update lines between
- *		     b_mod_top and b_mod_bot.
- *		   - if wp->w_redraw_top non-zero, redraw lines between
- *		     wp->w_redraw_top and wp->w_redr_bot.
- *		   - continue redrawing when syntax status is invalid.
- *		4. if scrolled up, update lines at the bottom.
+ * NOT_VALID    redraw the whole window
+ * SOME_VALID   redraw the whole window but do scroll when possible
+ * REDRAW_TOP   redraw the top w_upd_rows window lines, otherwise like VALID
+ * INVERTED     redraw the changed part of the Visual area
+ * INVERTED_ALL redraw the whole Visual area
+ * VALID        1. scroll up/down to adjust for a changed w_topline
+ *              2. update lines at the top when scrolled down
+ *              3. redraw changed text:
+ *                 - if wp->w_buffer->b_mod_set set, update lines between
+ *                   b_mod_top and b_mod_bot.
+ *                 - if wp->w_redraw_top non-zero, redraw lines between
+ *                   wp->w_redraw_top and wp->w_redr_bot.
+ *                 - continue redrawing when syntax status is invalid.
+ *              4. if scrolled up, update lines at the bottom.
  * This results in three areas that may need updating:
- * top:	from first row to top_end (when scrolled down)
+ * top: from first row to top_end (when scrolled down)
  * mid: from mid_start to mid_end (update inversion or changed text)
  * bot: from bot_start to last row (when scrolled up)
  */
@@ -824,10 +829,11 @@ static void win_update(win_T *wp, Providers *providers)
      * changes.  Set mod_bot to the first line after the changes.
      */
     mod_top = wp->w_redraw_top;
-    if (wp->w_redraw_bot != 0)
+    if (wp->w_redraw_bot != 0) {
       mod_bot = wp->w_redraw_bot + 1;
-    else
+    } else {
       mod_bot = 0;
+    }
     if (buf->b_mod_set) {
       if (mod_top == 0 || mod_top > buf->b_mod_top) {
         mod_top = buf->b_mod_top;
@@ -835,12 +841,14 @@ static void win_update(win_T *wp, Providers *providers)
          * in a pattern match. */
         if (syntax_present(wp)) {
           mod_top -= buf->b_s.b_syn_sync_linebreaks;
-          if (mod_top < 1)
+          if (mod_top < 1) {
             mod_top = 1;
+          }
         }
       }
-      if (mod_bot == 0 || mod_bot < buf->b_mod_bot)
+      if (mod_bot == 0 || mod_bot < buf->b_mod_bot) {
         mod_bot = buf->b_mod_bot;
+      }
 
       // When 'hlsearch' is on and using a multi-line search pattern, a
       // change in one line may make the Search highlighting in a
@@ -879,10 +887,11 @@ static void win_update(win_T *wp, Providers *providers)
        * to this line.  If there is no valid entry, use MAXLNUM. */
       lnumt = wp->w_topline;
       lnumb = MAXLNUM;
-      for (i = 0; i < wp->w_lines_valid; ++i)
+      for (i = 0; i < wp->w_lines_valid; ++i) {
         if (wp->w_lines[i].wl_valid) {
-          if (wp->w_lines[i].wl_lastlnum < mod_top)
+          if (wp->w_lines[i].wl_lastlnum < mod_top) {
             lnumt = wp->w_lines[i].wl_lastlnum + 1;
+          }
           if (lnumb == MAXLNUM && wp->w_lines[i].wl_lnum >= mod_bot) {
             lnumb = wp->w_lines[i].wl_lnum;
             // When there is a fold column it might need updating
@@ -892,6 +901,7 @@ static void win_update(win_T *wp, Providers *providers)
             }
           }
         }
+      }
 
       (void)hasFoldingWin(wp, mod_top, &mod_top, NULL, true, NULL);
       if (mod_top > lnumt) {
@@ -912,16 +922,18 @@ static void win_update(win_T *wp, Providers *providers)
      * If the end of the change is above w_topline: do like no change was
      * made, but redraw the first line to find changes in syntax. */
     if (mod_top != 0 && mod_top < wp->w_topline) {
-      if (mod_bot > wp->w_topline)
+      if (mod_bot > wp->w_topline) {
         mod_top = wp->w_topline;
-      else if (syntax_present(wp))
+      } else if (syntax_present(wp)) {
         top_end = 1;
+      }
     }
 
     /* When line numbers are displayed need to redraw all lines below
      * inserted/deleted lines. */
-    if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu)
+    if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu) {
       mod_bot = MAXLNUM;
+    }
   }
   wp->w_redraw_top = 0;  // reset for next time
   wp->w_redraw_bot = 0;
@@ -939,12 +951,13 @@ static void win_update(win_T *wp, Providers *providers)
         break;
       }
     }
-    if (top_end == 0)
+    if (top_end == 0) {
       /* not found (cannot happen?): redraw everything */
       type = NOT_VALID;
-    else
+    } else {
       /* top area defined, the rest is VALID */
       type = VALID;
+    }
   }
 
   /*
@@ -957,8 +970,7 @@ static void win_update(win_T *wp, Providers *providers)
    */
   if ((type == VALID || type == SOME_VALID
        || type == INVERTED || type == INVERTED_ALL)
-      && !wp->w_botfill && !wp->w_old_botfill
-      ) {
+      && !wp->w_botfill && !wp->w_old_botfill) {
     if (mod_top != 0
         && wp->w_topline == mod_top
         && (!wp->w_lines[0].wl_valid
@@ -986,14 +998,16 @@ static void win_update(win_T *wp, Providers *providers)
           }
           (void)hasFoldingWin(wp, ln, NULL, &ln, true, NULL);
         }
-      } else
+      } else {
         j = wp->w_lines[0].wl_lnum - wp->w_topline;
+      }
       if (j < wp->w_grid.Rows - 2) {               // not too far off
         i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
         /* insert extra lines for previously invisible filler lines */
-        if (wp->w_lines[0].wl_lnum != wp->w_topline)
+        if (wp->w_lines[0].wl_lnum != wp->w_topline) {
           i += diff_check_fill(wp, wp->w_lines[0].wl_lnum)
                - wp->w_old_topfill;
+        }
         if (i != 0 && i < wp->w_grid.Rows - 2) {  // less than a screen off
           // Try to insert the correct number of lines.
           // If not the last window, delete the lines at the bottom.
@@ -1052,10 +1066,11 @@ static void win_update(win_T *wp, Providers *providers)
          */
         /* If the topline didn't change, delete old filler lines,
          * otherwise delete filler lines of the new topline... */
-        if (wp->w_lines[0].wl_lnum == wp->w_topline)
+        if (wp->w_lines[0].wl_lnum == wp->w_topline) {
           row += wp->w_old_topfill;
-        else
+        } else {
           row += diff_check_fill(wp, wp->w_topline);
+        }
         /* ... but don't delete new filler lines. */
         row -= wp->w_topfill;
         if (row > 0) {
@@ -1065,7 +1080,7 @@ static void win_update(win_T *wp, Providers *providers)
         if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) {
           /*
            * Skip the lines (below the deleted lines) that are still
-           * valid and don't need redrawing.	Copy their info
+           * valid and don't need redrawing.    Copy their info
            * upwards, to compensate for the deleted lines.  Set
            * bot_start to the first row that needs redrawing.
            */
@@ -1090,10 +1105,11 @@ static void win_update(win_T *wp, Providers *providers)
           }
           /* Correct the first entry for filler lines at the top
            * when it won't get updated below. */
-          if (wp->w_p_diff && bot_start > 0)
+          if (wp->w_p_diff && bot_start > 0) {
             wp->w_lines[0].wl_size =
               plines_win_nofill(wp, wp->w_topline, true)
               + wp->w_topfill;
+          }
         }
       }
     }
@@ -1133,14 +1149,18 @@ static void win_update(win_T *wp, Providers *providers)
           to = curwin->w_cursor.lnum;
         }
         /* redraw more when the cursor moved as well */
-        if (wp->w_old_cursor_lnum < from)
+        if (wp->w_old_cursor_lnum < from) {
           from = wp->w_old_cursor_lnum;
-        if (wp->w_old_cursor_lnum > to)
+        }
+        if (wp->w_old_cursor_lnum > to) {
           to = wp->w_old_cursor_lnum;
-        if (wp->w_old_visual_lnum < from)
+        }
+        if (wp->w_old_visual_lnum < from) {
           from = wp->w_old_visual_lnum;
-        if (wp->w_old_visual_lnum > to)
+        }
+        if (wp->w_old_visual_lnum > to) {
           to = wp->w_old_visual_lnum;
+        }
       } else {
         /*
          * Find the line numbers that need to be updated: The lines
@@ -1153,21 +1173,26 @@ static void win_update(win_T *wp, Providers *providers)
         } else {
           from = wp->w_old_cursor_lnum;
           to = curwin->w_cursor.lnum;
-          if (from == 0)                /* Visual mode just started */
+          if (from == 0) {              /* Visual mode just started */
             from = to;
+          }
         }
 
         if (VIsual.lnum != wp->w_old_visual_lnum
             || VIsual.col != wp->w_old_visual_col) {
           if (wp->w_old_visual_lnum < from
-              && wp->w_old_visual_lnum != 0)
+              && wp->w_old_visual_lnum != 0) {
             from = wp->w_old_visual_lnum;
-          if (wp->w_old_visual_lnum > to)
+          }
+          if (wp->w_old_visual_lnum > to) {
             to = wp->w_old_visual_lnum;
-          if (VIsual.lnum < from)
+          }
+          if (VIsual.lnum < from) {
             from = VIsual.lnum;
-          if (VIsual.lnum > to)
+          }
+          if (VIsual.lnum > to) {
             to = VIsual.lnum;
+          }
         }
       }
 
@@ -1180,8 +1205,9 @@ static void win_update(win_T *wp, Providers *providers)
         colnr_T fromc, toc;
         int save_ve_flags = ve_flags;
 
-        if (curwin->w_p_lbr)
+        if (curwin->w_p_lbr) {
           ve_flags = VE_ALL;
+        }
 
         getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc);
         ve_flags = save_ve_flags;
@@ -1194,10 +1220,12 @@ static void win_update(win_T *wp, Providers *providers)
 
         if (fromc != wp->w_old_cursor_fcol
             || toc != wp->w_old_cursor_lcol) {
-          if (from > VIsual.lnum)
+          if (from > VIsual.lnum) {
             from = VIsual.lnum;
-          if (to < VIsual.lnum)
+          }
+          if (to < VIsual.lnum) {
             to = VIsual.lnum;
+          }
         }
         wp->w_old_cursor_fcol = fromc;
         wp->w_old_cursor_lcol = toc;
@@ -1216,18 +1244,21 @@ static void win_update(win_T *wp, Providers *providers)
     /*
      * There is no need to update lines above the top of the window.
      */
-    if (from < wp->w_topline)
+    if (from < wp->w_topline) {
       from = wp->w_topline;
+    }
 
     /*
      * If we know the value of w_botline, use it to restrict the update to
      * the lines that are visible in the window.
      */
     if (wp->w_valid & VALID_BOTLINE) {
-      if (from >= wp->w_botline)
+      if (from >= wp->w_botline) {
         from = wp->w_botline - 1;
-      if (to >= wp->w_botline)
+      }
+      if (to >= wp->w_botline) {
         to = wp->w_botline - 1;
+      }
     }
 
     /*
@@ -1243,20 +1274,23 @@ static void win_update(win_T *wp, Providers *providers)
       lnum = wp->w_topline;
       idx = 0;
       srow = 0;
-      if (scrolled_down)
+      if (scrolled_down) {
         mid_start = top_end;
-      else
+      } else {
         mid_start = 0;
+      }
       while (lnum < from && idx < wp->w_lines_valid) {          /* find start */
-        if (wp->w_lines[idx].wl_valid)
+        if (wp->w_lines[idx].wl_valid) {
           mid_start += wp->w_lines[idx].wl_size;
-        else if (!scrolled_down)
+        } else if (!scrolled_down) {
           srow += wp->w_lines[idx].wl_size;
+        }
         ++idx;
-        if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid)
+        if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid) {
           lnum = wp->w_lines[idx].wl_lnum;
-        else
+        } else {
           ++lnum;
+        }
       }
       srow += mid_start;
       mid_end = wp->w_grid.Rows;
@@ -1400,8 +1434,9 @@ static void win_update(win_T *wp, Providers *providers)
           /* Only valid lines have a meaningful wl_lnum.  Invalid
            * lines are part of the changed area. */
           if (wp->w_lines[i].wl_valid
-              && wp->w_lines[i].wl_lnum == mod_bot)
+              && wp->w_lines[i].wl_lnum == mod_bot) {
             break;
+          }
           old_rows += wp->w_lines[i].wl_size;
           if (wp->w_lines[i].wl_valid
               && wp->w_lines[i].wl_lastlnum + 1 == mod_bot) {
@@ -1409,8 +1444,9 @@ static void win_update(win_T *wp, Providers *providers)
              * Add following invalid entries. */
             ++i;
             while (i < wp->w_lines_valid
-                   && !wp->w_lines[i].wl_valid)
+                   && !wp->w_lines[i].wl_valid) {
               old_rows += wp->w_lines[i++].wl_size;
+            }
             break;
           }
         }
@@ -1490,10 +1526,11 @@ static void win_update(win_T *wp, Providers *providers)
                 x += wp->w_lines[j++].wl_size;
                 ++i;
               }
-              if (bot_start > x)
+              if (bot_start > x) {
                 bot_start = x;
+              }
             } else {       /* j > i */
-                             /* move entries in w_lines[] downwards */
+                           /* move entries in w_lines[] downwards */
               j -= i;
               wp->w_lines_valid += j;
               if (wp->w_lines_valid > wp->w_grid.Rows) {
@@ -1529,8 +1566,7 @@ static void win_update(win_T *wp, Providers *providers)
           && lnum > wp->w_topline
           && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
           && srow + wp->w_lines[idx].wl_size > wp->w_grid.Rows
-          && diff_check_fill(wp, lnum) == 0
-          ) {
+          && diff_check_fill(wp, lnum) == 0) {
         // This line is not going to fit.  Don't draw anything here,
         // will draw "@  " lines below.
         row = wp->w_grid.Rows + 1;
@@ -1538,8 +1574,9 @@ static void win_update(win_T *wp, Providers *providers)
         prepare_search_hl(wp, lnum);
         /* Let the syntax stuff know we skipped a few lines. */
         if (syntax_last_parsed != 0 && syntax_last_parsed + 1 < lnum
-            && syntax_present(wp))
+            && syntax_present(wp)) {
           syntax_end_parsing(syntax_last_parsed + 1);
+        }
 
         // Display one line
         row = win_line(wp, lnum, srow,
@@ -1603,14 +1640,16 @@ static void win_update(win_T *wp, Providers *providers)
    */
 
 
-  if (idx > wp->w_lines_valid)
+  if (idx > wp->w_lines_valid) {
     wp->w_lines_valid = idx;
+  }
 
   /*
    * Let the syntax stuff know we stop parsing here.
    */
-  if (syntax_last_parsed != 0 && syntax_present(wp))
+  if (syntax_last_parsed != 0 && syntax_present(wp)) {
     syntax_end_parsing(syntax_last_parsed + 1);
+  }
 
   /*
    * If we didn't hit the end of the file, and we didn't finish the last
@@ -1668,8 +1707,9 @@ static void win_update(win_T *wp, Providers *providers)
         win_draw_end(wp, i, i, true, row, row + (int)j, HLF_DED);
         row += j;
       }
-    } else if (dollar_vcol == -1)
+    } else if (dollar_vcol == -1) {
       wp->w_botline = lnum;
+    }
 
     // make sure the rest of the screen is blank
     // write the 'eob' character to rows that aren't part of the file.
@@ -1755,8 +1795,9 @@ static void win_update(win_T *wp, Providers *providers)
 
 
   /* restore got_int, unless CTRL-C was hit while redrawing */
-  if (!got_int)
+  if (!got_int) {
     got_int = save_got_int;
+  }
 }  // NOLINT(readability/fn_size)
 
 /// Returns width of the signcolumn that should be used for the whole window
@@ -1776,8 +1817,8 @@ int win_signcol_width(win_T *wp)
 
 /// Call grid_fill() with columns adjusted for 'rightleft' if needed.
 /// Return the new offset.
-static int win_fill_end(win_T *wp, int c1, int c2, int off, int width, int row,
-                        int endrow, int attr)
+static int win_fill_end(win_T *wp, int c1, int c2, int off, int width, int row, int endrow,
+                        int attr)
 {
   int nn = off + width;
 
@@ -1798,8 +1839,7 @@ static int win_fill_end(win_T *wp, int c1, int c2, int off, int width, int row,
 /// Clear lines near the end of the window and mark the unused lines with "c1".
 /// Use "c2" as filler character.
 /// When "draw_margin" is true, then draw the sign/fold/number columns.
-static void win_draw_end(win_T *wp, int c1, int c2, bool draw_margin, int row,
-                         int endrow, hlf_T hl)
+static void win_draw_end(win_T *wp, int c1, int c2, bool draw_margin, int row, int endrow, hlf_T hl)
 {
   assert(hl >= 0 && hl < HLF_COUNT);
   int n = 0;
@@ -1844,8 +1884,9 @@ static void win_draw_end(win_T *wp, int c1, int c2, bool draw_margin, int row,
 /// @return  true when there are columns to draw.
 static bool advance_color_col(int vcol, int **color_cols)
 {
-  while (**color_cols >= 0 && vcol > **color_cols)
+  while (**color_cols >= 0 && vcol > **color_cols) {
     ++*color_cols;
+  }
   return **color_cols >= 0;
 }
 
@@ -1923,13 +1964,7 @@ static int line_putchar(LineState *s, schar_T *dest, int maxcells, bool rl)
 ///
 /// Assume monocell characters
 /// @return number of chars added to \param p
-static size_t
-fill_foldcolumn(
-    char_u *p,
-    win_T *wp,
-    foldinfo_T foldinfo,
-    linenr_T lnum
-)
+static size_t fill_foldcolumn(char_u *p, win_T *wp, foldinfo_T foldinfo, linenr_T lnum)
 {
   int i = 0;
   int level;
@@ -1998,9 +2033,8 @@ fill_foldcolumn(
 ///                            or explicitly return `false`.
 ///
 /// @return             the number of last row the line occupies.
-static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
-                    bool nochange, bool number_only, foldinfo_T foldinfo,
-                    Providers *providers)
+static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
+                    bool number_only, foldinfo_T foldinfo, Providers *providers)
 {
   int c = 0;                          // init for GCC
   long vcol = 0;                      // virtual column (for tabs)
@@ -2155,8 +2189,9 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
     boguscols = 0; \
   }
 
-  if (startrow > endrow)                /* past the end already! */
+  if (startrow > endrow) {              /* past the end already! */
     return startrow;
+  }
 
   row = startrow;
 
@@ -2327,7 +2362,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
         area_highlighting = true;
         attr = win_hl_attr(wp, HLF_V);
       }
-    // handle 'incsearch' and ":s///c" highlighting
+      // handle 'incsearch' and ":s///c" highlighting
     } else if (highlight_match
                && wp == curwin
                && !has_fold
@@ -2356,19 +2391,22 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
   filler_lines = diff_check(wp, lnum);
   if (filler_lines < 0) {
     if (filler_lines == -1) {
-      if (diff_find_change(wp, lnum, &change_start, &change_end))
+      if (diff_find_change(wp, lnum, &change_start, &change_end)) {
         diff_hlf = HLF_ADD;             /* added line */
-      else if (change_start == 0)
+      } else if (change_start == 0) {
         diff_hlf = HLF_TXD;             /* changed text */
-      else
+      } else {
         diff_hlf = HLF_CHD;             /* changed line */
-    } else
+      }
+    } else {
       diff_hlf = HLF_ADD;               /* added line */
+    }
     filler_lines = 0;
     area_highlighting = TRUE;
   }
-  if (lnum == wp->w_topline)
+  if (lnum == wp->w_topline) {
     filler_lines = wp->w_topfill;
+  }
   filler_todo = filler_lines;
 
   // Cursor line highlighting for 'cursorline' in the current window.
@@ -2475,7 +2513,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
       while (trailcol > (colnr_T)0 && ascii_iswhite(ptr[trailcol - 1])) {
         trailcol--;
       }
-      trailcol += (colnr_T) (ptr - line);
+      trailcol += (colnr_T)(ptr - line);
     }
     // find end of leading whitespace
     if (wp->w_p_lcs_chars.lead) {
@@ -2497,10 +2535,11 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
    * 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the
    * first character to be displayed.
    */
-  if (wp->w_p_wrap)
+  if (wp->w_p_wrap) {
     v = wp->w_skipcol;
-  else
+  } else {
     v = wp->w_leftcol;
+  }
   if (v > 0 && !number_only) {
     char_u  *prev_ptr = ptr;
     while (vcol < v && *ptr != NUL) {
@@ -2539,10 +2578,11 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
      * Adjust for when the inverted text is before the screen,
      * and when the start of the inverted text is before the screen.
      */
-    if (tocol <= vcol)
+    if (tocol <= vcol) {
       fromcol = 0;
-    else if (fromcol >= 0 && fromcol < vcol)
+    } else if (fromcol >= 0 && fromcol < vcol) {
       fromcol = vcol;
+    }
 
     // When w_skipcol is non-zero, first line needs 'showbreak'
     if (wp->w_p_wrap) {
@@ -2575,8 +2615,9 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
         word_end = wp->w_cursor.col + (int)len + 1;
 
         /* Turn index into actual attributes. */
-        if (spell_hlf != HLF_COUNT)
+        if (spell_hlf != HLF_COUNT) {
           spell_attr = highlight_attr[spell_hlf];
+        }
       }
       wp->w_cursor = pos;
 
@@ -2598,12 +2639,14 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
          * cursor */
         fromcol_prev = fromcol;
         fromcol = -1;
-      } else if ((colnr_T)fromcol < wp->w_virtcol)
+      } else if ((colnr_T)fromcol < wp->w_virtcol) {
         /* restart highlighting after the cursor */
         fromcol_prev = wp->w_virtcol;
+      }
     }
-    if (fromcol >= tocol)
+    if (fromcol >= tocol) {
       fromcol = -1;
+    }
   }
 
   /*
@@ -2613,8 +2656,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
   cur = wp->w_match_head;
   shl_flag = false;
   while ((cur != NULL || !shl_flag) && !number_only
-         && !has_fold
-         ) {
+         && !has_fold) {
     if (!shl_flag) {
       shl = &search_hl;
       shl_flag = true;
@@ -2647,18 +2689,18 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
         shl->startcol = 0;
       }
       if (lnum == shl->lnum + shl->rm.endpos[0].lnum
-                  - shl->rm.startpos[0].lnum) {
-          shl->endcol = shl->rm.endpos[0].col;
+          - shl->rm.startpos[0].lnum) {
+        shl->endcol = shl->rm.endpos[0].col;
       } else {
-          shl->endcol = MAXCOL;
+        shl->endcol = MAXCOL;
       }
       // Highlight one character for an empty match.
       if (shl->startcol == shl->endcol) {
-          if (line[shl->endcol] != NUL) {
-              shl->endcol += (*mb_ptr2len)(line + shl->endcol);
-          } else {
-              ++shl->endcol;
-          }
+        if (line[shl->endcol] != NUL) {
+          shl->endcol += (*mb_ptr2len)(line + shl->endcol);
+        } else {
+          ++shl->endcol;
+        }
       }
       if ((long)shl->startcol < v) {   // match at leftcol
         shl->attr_cur = shl->attr;
@@ -2667,8 +2709,9 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
       }
       area_highlighting = true;
     }
-    if (shl != &search_hl && cur != NULL)
+    if (shl != &search_hl && cur != NULL) {
       cur = cur->next;
+    }
   }
 
   unsigned off = 0;  // Offset relative start of line
@@ -2733,18 +2776,17 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
 
       // sign column, this is hit until sign_idx reaches count
       if (draw_state == WL_SIGN - 1 && n_extra == 0) {
-          draw_state = WL_SIGN;
-          /* Show the sign column when there are any signs in this
-           * buffer or when using Netbeans. */
-          int count = win_signcol_count(wp);
-          if (count > 0) {
-              get_sign_display_info(
-                  false, wp, sattrs, row,
-                  startrow, filler_lines, filler_todo, count,
-                  &c_extra, &c_final, extra, sizeof(extra),
-                  &p_extra, &n_extra,
-                  &char_attr, &draw_state, &sign_idx);
-          }
+        draw_state = WL_SIGN;
+        /* Show the sign column when there are any signs in this
+         * buffer or when using Netbeans. */
+        int count = win_signcol_count(wp);
+        if (count > 0) {
+          get_sign_display_info(false, wp, sattrs, row,
+                                startrow, filler_lines, filler_todo, count,
+                                &c_extra, &c_final, extra, sizeof(extra),
+                                &p_extra, &n_extra,
+                                &char_attr, &draw_state, &sign_idx);
+        }
       }
 
       if (draw_state == WL_NR - 1 && n_extra == 0) {
@@ -2760,12 +2802,11 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
           if (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u'
               && num_signs > 0) {
             int count = win_signcol_count(wp);
-            get_sign_display_info(
-                true, wp, sattrs, row,
-                startrow, filler_lines, filler_todo, count,
-                &c_extra, &c_final, extra, sizeof(extra),
-                &p_extra, &n_extra,
-                &char_attr, &draw_state, &sign_idx);
+            get_sign_display_info(true, wp, sattrs, row,
+                                  startrow, filler_lines, filler_todo, count,
+                                  &c_extra, &c_final, extra, sizeof(extra),
+                                  &p_extra, &n_extra,
+                                  &char_attr, &draw_state, &sign_idx);
           } else {
             if (row == startrow + filler_lines) {
               // Draw the line number (empty space after wrapping). */
@@ -2920,8 +2961,9 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
           vcol_sbr = vcol + MB_CHARLEN(p_sbr);
           /* Correct end of highlighted area for 'showbreak',
            * required when 'linebreak' is also set. */
-          if (tocol == vcol)
+          if (tocol == vcol) {
             tocol += n_extra;
+          }
           // Combine 'showbreak' with 'cursorline', prioritizing 'showbreak'.
           if (cul_attr) {
             char_attr = hl_combine_attr(cul_attr, char_attr);
@@ -2993,20 +3035,20 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
         && vcol == 0
         && n_extra == 0
         && row == startrow) {
-        char_attr = win_hl_attr(wp, HLF_FL);
+      char_attr = win_hl_attr(wp, HLF_FL);
 
-        linenr_T lnume = lnum + foldinfo.fi_lines - 1;
-        memset(buf_fold, ' ', FOLD_TEXT_LEN);