docs: add style rule regarding initialization

Specifically, specify that each initialization should be done on a
separate line.

36 files changed, 220 insertions, 162 deletions

diff --git a/runtime/doc/dev_style.txt b/runtime/doc/dev_style.txt
index 02fd07ce24..ee8a2a3c3b 100644
--- a/runtime/doc/dev_style.txt
+++ b/runtime/doc/dev_style.txt
@@ -73,6 +73,24 @@ should be used instead of declaration and assignment, e.g. >c
     int j = g();  // GOOD: declaration has initialization.
 
 
+Initialization ~
+
+Multiple declarations can be defined in one line if they aren't initialized,
+but each initialization should be done on a separate line.
+
+>c
+    int i;
+    int j; // GOOD
+
+    int i, j;   // GOOD: multiple declarations, no initialization.
+
+    int i = 0;
+    int j = 0;  // GOOD: one initialization per line.
+
+    int i = 0, j;  // BAD: multiple declarations with initialization.
+
+    int i = 0, j = 0;  // BAD: multiple declarations with initialization.
+
 ==============================================================================
 Nvim-Specific Magic
 
diff --git a/src/nvim/change.c b/src/nvim/change.c
index c528ffba20..622eb3b9a5 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -2121,10 +2121,8 @@ int get_last_leader_offset(char *line, char **flags)
   int result = -1;
   int j;
   int lower_check_bound = 0;
-  char *string;
   char *com_leader;
   char *com_flags;
-  char *list;
   char part_buf[COM_MAX_LEN];         // buffer for one option part
 
   // Repeat to match several nested comment strings.
@@ -2132,13 +2130,13 @@ int get_last_leader_offset(char *line, char **flags)
   while (--i >= lower_check_bound) {
     // scan through the 'comments' option for a match
     int found_one = false;
-    for (list = curbuf->b_p_com; *list;) {
+    for (char *list = curbuf->b_p_com; *list;) {
       char *flags_save = list;
 
       // Get one option part into part_buf[].  Advance list to next one.
       // put string at start of string.
       (void)copy_option_part(&list, part_buf, COM_MAX_LEN, ",");
-      string = vim_strchr(part_buf, ':');
+      char *string = vim_strchr(part_buf, ':');
       if (string == NULL) {  // If everything is fine, this cannot actually
                              // happen.
         continue;
@@ -2216,14 +2214,14 @@ int get_last_leader_offset(char *line, char **flags)
       }
       int len1 = (int)strlen(com_leader);
 
-      for (list = curbuf->b_p_com; *list;) {
+      for (char *list = curbuf->b_p_com; *list;) {
         char *flags_save = list;
 
         (void)copy_option_part(&list, part_buf2, COM_MAX_LEN, ",");
         if (flags_save == com_flags) {
           continue;
         }
-        string = vim_strchr(part_buf2, ':');
+        char *string = vim_strchr(part_buf2, ':');
         string++;
         while (ascii_iswhite(*string)) {
           string++;
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 09a0a43e2f..94eeb9bc77 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -928,7 +928,6 @@ int showmode(void)
 
   bool can_show_mode = (p_ch != 0 || ui_has(kUIMessages));
   if ((do_mode || reg_recording != 0) && can_show_mode) {
-    int sub_attr;
     if (skip_showmode()) {
       return 0;  // show mode later
     }
@@ -955,6 +954,7 @@ int showmode(void)
     lines_left = 0;
 
     if (do_mode) {
+      int sub_attr;
       msg_puts_attr("--", attr);
       // CTRL-X in Insert mode
       if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) {
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index ba2885a162..0fcb665f0f 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -3008,7 +3008,6 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
   int try_match;
   int try_match_word;
   char *p;
-  char *line;
   bool icase;
 
   if (keytyped == NUL) {
@@ -3150,7 +3149,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
 
           // Just completed a word, check if it starts with "look".
           // search back for the start of a word.
-          line = get_cursor_line_ptr();
+          char *line = get_cursor_line_ptr();
           for (s = line + curwin->w_cursor.col; s > line; s = n) {
             n = mb_prevptr(line, s);
             if (!vim_iswordp(n)) {
@@ -3169,7 +3168,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           if (keytyped == (int)(uint8_t)p[-1]
               || (icase && keytyped < 256
                   && TOLOWER_LOC(keytyped) == TOLOWER_LOC((uint8_t)p[-1]))) {
-            line = get_cursor_pos_ptr();
+            char *line = get_cursor_pos_ptr();
             assert(p >= look && (uintmax_t)(p - look) <= SIZE_MAX);
             if ((curwin->w_cursor.col == (colnr_T)(p - look)
                  || !vim_iswordc((uint8_t)line[-(p - look) - 1]))
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index d8134c2360..7d869881e8 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2863,7 +2863,8 @@ static int eval5(char **arg, typval_T *rettv, evalarg_T *const evalarg)
       } else {
         bool error = false;
         varnumber_T n1, n2;
-        float_T f1 = 0, f2 = 0;
+        float_T f1 = 0;
+        float_T f2 = 0;
 
         if (rettv->v_type == VAR_FLOAT) {
           f1 = rettv->vval.v_float;
@@ -2954,7 +2955,8 @@ static int eval6(char **arg, typval_T *rettv, evalarg_T *const evalarg, bool wan
     }
 
     varnumber_T n1, n2;
-    float_T f1 = 0, f2 = 0;
+    float_T f1 = 0;
+    float_T f2 = 0;
     bool error = false;
     const bool evaluate = evalarg == NULL ? 0 : (evalarg->eval_flags & EVAL_EVALUATE);
     if (evaluate) {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index ea68c010d6..81ae208560 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -4054,8 +4054,8 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   bool clear_env = false;
   bool overlapped = false;
   ChannelStdinMode stdin_mode = kChannelStdinPipe;
-  CallbackReader on_stdout = CALLBACK_READER_INIT,
-                 on_stderr = CALLBACK_READER_INIT;
+  CallbackReader on_stdout = CALLBACK_READER_INIT;
+  CallbackReader on_stderr = CALLBACK_READER_INIT;
   Callback on_exit = CALLBACK_NONE;
   char *cwd = NULL;
   dictitem_T *job_env = NULL;
@@ -4118,7 +4118,8 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
   }
 
-  uint16_t width = 0, height = 0;
+  uint16_t width = 0;
+  uint16_t height = 0;
   char *term_name = NULL;
 
   if (pty) {
@@ -8553,8 +8554,8 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
 
-  CallbackReader on_stdout = CALLBACK_READER_INIT,
-                 on_stderr = CALLBACK_READER_INIT;
+  CallbackReader on_stdout = CALLBACK_READER_INIT;
+  CallbackReader on_stderr = CALLBACK_READER_INIT;
   Callback on_exit = CALLBACK_NONE;
   dict_T *job_opts = NULL;
   const char *cwd = ".";
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index ebc84922cb..cce02e6daf 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -105,7 +105,6 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int *
   char *arg = *argp;
   char *p = arg;
   uint8_t c;
-  int i;
 
   if (newargs != NULL) {
     ga_init(newargs, (int)sizeof(char *), 3);
@@ -147,7 +146,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int *
         arg = xstrdup(arg);
 
         // Check for duplicate argument name.
-        for (i = 0; i < newargs->ga_len; i++) {
+        for (int i = 0; i < newargs->ga_len; i++) {
           if (strcmp(((char **)(newargs->ga_data))[i], arg) == 0) {
             semsg(_("E853: Duplicate argument name: %s"), arg);
             xfree(arg);
@@ -922,7 +921,6 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
   static int depth = 0;
   dictitem_T *v;
   int fixvar_idx = 0;           // index in fc_fixvar[]
-  int ai;
   bool islambda = false;
   char numbuf[NUMBUFLEN];
   char *name;
@@ -1025,7 +1023,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
     bool isdefault = false;
     typval_T def_rettv;
 
-    ai = i - fp->uf_args.ga_len;
+    int ai = i - fp->uf_args.ga_len;
     if (ai < 0) {
       // named argument a:name
       name = FUNCARG(fp, i);
diff --git a/src/nvim/eval/window.c b/src/nvim/eval/window.c
index d1ee2ea356..02f214f262 100644
--- a/src/nvim/eval/window.c
+++ b/src/nvim/eval/window.c
@@ -710,7 +710,8 @@ void f_win_splitmove(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
 
-  int flags = 0, size = 0;
+  int flags = 0;
+  int size = 0;
 
   if (argvars[2].v_type != VAR_UNKNOWN) {
     dict_T *d;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 96429c96f7..a0e9b537e8 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -618,7 +618,8 @@ void ex_sort(exarg_T *eap)
     goto sortend;
   }
 
-  bcount_t old_count = 0, new_count = 0;
+  bcount_t old_count = 0;
+  bcount_t new_count = 0;
 
   // Insert the lines in the sorted order below the last one.
   linenr_T lnum = eap->line2;
@@ -3303,7 +3304,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
     .do_number = false,
     .do_ic = kSubHonorOptions
   };
-  char *pat = NULL, *sub = NULL;  // init for GCC
+  char *pat = NULL;
+  char *sub = NULL;  // init for GCC
   int delimiter;
   bool has_second_delim = false;
   int sublen;
@@ -3501,7 +3503,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
       colnr_T copycol;
       colnr_T matchcol;
       colnr_T prev_matchcol = MAXCOL;
-      char *new_end, *new_start = NULL;
+      char *new_end;
+      char *new_start = NULL;
       int new_start_len = 0;
       char *p1;
       bool did_sub = false;
@@ -3971,7 +3974,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
 
           // TODO(bfredl): this has some robustness issues, look into later.
           bcount_t replaced_bytes = 0;
-          lpos_T start = regmatch.startpos[0], end = regmatch.endpos[0];
+          lpos_T start = regmatch.startpos[0];
+          lpos_T end = regmatch.endpos[0];
           for (i = 0; i < nmatch - 1; i++) {
             replaced_bytes += (bcount_t)strlen(ml_get((linenr_T)(lnum_start + i))) + 1;
           }
diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c
index f914137ccc..f305b6d506 100644
--- a/src/nvim/extmark.c
+++ b/src/nvim/extmark.c
@@ -435,8 +435,10 @@ void extmark_adjust(buf_T *buf, linenr_T line1, linenr_T line2, linenr_T amount,
     return;
   }
   bcount_t start_byte = ml_find_line_or_offset(buf, line1, NULL, true);
-  bcount_t old_byte = 0, new_byte = 0;
-  int old_row, new_row;
+  bcount_t old_byte = 0;
+  bcount_t new_byte = 0;
+  int old_row;
+  int new_row;
   if (amount == MAXLNUM) {
     old_row = line2 - line1 + 1;
     // TODO(bfredl): ej kasta?
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index e372b9f461..9e90ab9439 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -849,7 +849,6 @@ void foldUpdateAll(win_T *win)
 int foldMoveTo(const bool updown, const int dir, const int count)
 {
   int retval = FAIL;
-  linenr_T lnum;
   fold_T *fp;
 
   checkupdate(curwin);
@@ -908,7 +907,7 @@ int foldMoveTo(const bool updown, const int dir, const int count)
         if (dir == FORWARD) {
           // to start of next fold if there is one
           if (fp + 1 - (fold_T *)gap->ga_data < gap->ga_len) {
-            lnum = fp[1].fd_top + lnum_off;
+            linenr_T lnum = fp[1].fd_top + lnum_off;
             if (lnum > curwin->w_cursor.lnum) {
               lnum_found = lnum;
             }
@@ -916,7 +915,7 @@ int foldMoveTo(const bool updown, const int dir, const int count)
         } else {
           // to end of previous fold if there is one
           if (fp > (fold_T *)gap->ga_data) {
-            lnum = fp[-1].fd_top + lnum_off + fp[-1].fd_len - 1;
+            linenr_T lnum = fp[-1].fd_top + lnum_off + fp[-1].fd_len - 1;
             if (lnum < curwin->w_cursor.lnum) {
               lnum_found = lnum;
             }
@@ -926,12 +925,12 @@ int foldMoveTo(const bool updown, const int dir, const int count)
         // Open fold found, set cursor to its start/end and then check
         // nested folds.
         if (dir == FORWARD) {
-          lnum = fp->fd_top + lnum_off + fp->fd_len - 1;
+          linenr_T lnum = fp->fd_top + lnum_off + fp->fd_len - 1;
           if (lnum > curwin->w_cursor.lnum) {
             lnum_found = lnum;
           }
         } else {
-          lnum = fp->fd_top + lnum_off;
+          linenr_T lnum = fp->fd_top + lnum_off;
           if (lnum < curwin->w_cursor.lnum) {
             lnum_found = lnum;
           }
@@ -999,7 +998,6 @@ void foldAdjustVisual(void)
   }
 
   pos_T *start, *end;
-  char *ptr;
 
   if (ltoreq(VIsual, curwin->w_cursor)) {
     start = &VIsual;
@@ -1016,7 +1014,7 @@ void foldAdjustVisual(void)
     return;
   }
 
-  ptr = ml_get(end->lnum);
+  char *ptr = ml_get(end->lnum);
   end->col = (colnr_T)strlen(ptr);
   if (end->col > 0 && *p_sel == 'o') {
     end->col--;
@@ -2802,7 +2800,8 @@ void foldMoveRange(win_T *const wp, garray_T *gap, const linenr_T line1, const l
   // Case 5 or 6: changes rely on whether there are folds between the end of
   // this fold and "dest".
   size_t move_start = FOLD_INDEX(fp, gap);
-  size_t move_end = 0, dest_index = 0;
+  size_t move_end = 0;
+  size_t dest_index = 0;
   for (; VALID_FOLD(fp, gap) && fp->fd_top <= dest; fp++) {
     if (fp->fd_top <= line2) {
       // 5, or 6
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index c0fa63818e..e153b03bc1 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -124,7 +124,7 @@ EXTERN bool redraw_cmdline INIT( = false);          // cmdline must be redrawn
 EXTERN bool redraw_mode INIT( = false);             // mode must be redrawn
 EXTERN bool clear_cmdline INIT( = false);           // cmdline must be cleared
 EXTERN bool mode_displayed INIT( = false);          // mode is being displayed
-EXTERN int cmdline_star INIT( = false);             // cmdline is encrypted
+EXTERN int cmdline_star INIT( = 0);                 // cmdline is encrypted
 EXTERN bool redrawing_cmdline INIT( = false);       // cmdline is being redrawn
 EXTERN bool cmdline_was_last_drawn INIT( = false);  // cmdline was last drawn
 
@@ -591,9 +591,9 @@ EXTERN int reg_executing INIT( = 0);     // register being executed or zero
 EXTERN bool pending_end_reg_executing INIT( = false);
 EXTERN int reg_recorded INIT( = 0);      // last recorded register or zero
 
-EXTERN int no_mapping INIT( = false);    // currently no mapping allowed
+EXTERN int no_mapping INIT( = 0);        // currently no mapping allowed
 EXTERN int no_zero_mapping INIT( = 0);   // mapping zero not allowed
-EXTERN int allow_keys INIT( = false);    // allow key codes when no_mapping is set
+EXTERN int allow_keys INIT( = 0);        // allow key codes when no_mapping is set
 EXTERN int no_u_sync INIT( = 0);         // Don't call u_sync()
 EXTERN int u_sync_once INIT( = 0);       // Call u_sync() once when evaluating
                                          // an expression.
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index 58884e7f72..9830f25dcb 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -538,7 +538,8 @@ void grid_line_flush_if_valid_row(void)
 void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int end_col, int c1,
                int c2, int attr)
 {
-  int row_off = 0, col_off = 0;
+  int row_off = 0;
+  int col_off = 0;
   grid_adjust(&grid, &row_off, &col_off);
   start_row += row_off;
   end_row += row_off;
@@ -650,8 +651,6 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int col, int endcol
 {
   bool redraw_next;                         // redraw_this for next character
   bool clear_next = false;
-  int char_cells;                           // 1: normal char
-                                            // 2: occupies two display cells
   assert(0 <= row && row < grid->rows);
   // TODO(bfredl): check all callsites and eliminate
   // Check for illegal col, just in case
@@ -703,10 +702,12 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int col, int endcol
 
   redraw_next = grid_char_needs_redraw(grid, col, (size_t)col + off_to, endcol - col);
 
-  int start_dirty = -1, end_dirty = 0;
+  int start_dirty = -1;
+  int end_dirty = 0;
 
   while (col < endcol) {
-    char_cells = 1;
+    int char_cells = 1;  // 1: normal char
+                         // 2: occupies two display cells
     if (col + 1 < endcol && linebuf_char[col + 1] == 0) {
       char_cells = 2;
     }
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index 141761c52e..6684a20607 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -713,7 +713,8 @@ int hl_blend_attrs(int back_attr, int front_attr, bool *through)
 
 static int rgb_blend(int ratio, int rgb1, int rgb2)
 {
-  int a = ratio, b = 100 - ratio;
+  int a = ratio;
+  int b = 100 - ratio;
   int r1 = (rgb1 & 0xFF0000) >> 16;
   int g1 = (rgb1 & 0x00FF00) >> 8;
   int b1 = (rgb1 & 0x0000FF) >> 0;
@@ -940,7 +941,11 @@ HlAttrs dict2hlattrs(Dict(highlight) *dict, bool use_rgb, int *link_id, Error *e
 {
 #define HAS_KEY_X(d, key) HAS_KEY(d, highlight, key)
   HlAttrs hlattrs = HLATTRS_INIT;
-  int32_t fg = -1, bg = -1, ctermfg = -1, ctermbg = -1, sp = -1;
+  int32_t fg = -1;
+  int32_t bg = -1;
+  int32_t ctermfg = -1;
+  int32_t ctermbg = -1;
+  int32_t sp = -1;
   int blend = -1;
   int16_t mask = 0;
   int16_t cterm_mask = 0;
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index 925317e7cb..61422561e0 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -53,15 +53,13 @@
 bool tabstop_set(char *var, colnr_T **array)
 {
   int valcount = 1;
-  int t;
-  char *cp;
 
   if (var[0] == NUL || (var[0] == '0' && var[1] == NUL)) {
     *array = NULL;
     return true;
   }
 
-  for (cp = var; *cp != NUL; cp++) {
+  for (char *cp = var; *cp != NUL; cp++) {
     if (cp == var || cp[-1] == ',') {
       char *end;
 
@@ -89,8 +87,8 @@ bool tabstop_set(char *var, colnr_T **array)
   *array = (colnr_T *)xmalloc((unsigned)(valcount + 1) * sizeof(int));
   (*array)[0] = (colnr_T)valcount;
 
-  t = 1;
-  for (cp = var; *cp != NUL;) {
+  int t = 1;
+  for (char *cp = var; *cp != NUL;) {
     int n = atoi(cp);
 
     // Catch negative values, overflow and ridiculous big values.
@@ -171,14 +169,13 @@ int tabstop_at(colnr_T col, OptInt ts, const colnr_T *vts)
 colnr_T tabstop_start(colnr_T col, int ts, colnr_T *vts)
 {
   colnr_T tabcol = 0;
-  int t;
 
   if (vts == NULL || vts[0] == 0) {
     return ((col / ts) * ts);
   }
 
   const int tabcount = vts[0];
-  for (t = 1; t <= tabcount; t++) {
+  for (int t = 1; t <= tabcount; t++) {
     tabcol += vts[t];
     if (tabcol > col) {
       return (tabcol - vts[t]);
@@ -258,8 +255,6 @@ void tabstop_fromto(colnr_T start_col, colnr_T end_col, int ts_arg, const colnr_
 /// See if two tabstop arrays contain the same values.
 bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2)
 {
-  int t;
-
   if ((ts1 == 0 && ts2) || (ts1 && ts2 == 0)) {
     return false;
   }
@@ -270,7 +265,7 @@ bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2)
     return false;
   }
 
-  for (t = 1; t <= ts1[0]; t++) {
+  for (int t = 1; t <= ts1[0]; t++) {
     if (ts1[t] != ts2[t]) {
       return false;
     }
@@ -282,15 +277,12 @@ bool tabstop_eq(const colnr_T *ts1, const colnr_T *ts2)
 /// Copy a tabstop array, allocating space for the new array.
 int *tabstop_copy(const int *oldts)
 {
-  int *newts;
-  int t;
-
   if (oldts == 0) {
     return 0;
   }
 
-  newts = xmalloc((unsigned)(oldts[0] + 1) * sizeof(int));
-  for (t = 0; t <= oldts[0]; t++) {
+  int *newts = xmalloc((unsigned)(oldts[0] + 1) * sizeof(int));
+  for (int t = 0; t <= oldts[0]; t++) {
     newts[t] = oldts[t];
   }
 
@@ -431,25 +423,22 @@ int get_indent_str_vtab(const char *ptr, OptInt ts, colnr_T *vts, bool list)
   return count;
 }
 
-// Set the indent of the current line.
-// Leaves the cursor on the first non-blank in the line.
-// Caller must take care of undo.
-// "flags":
-//  SIN_CHANGED:    call changed_bytes() if the line was changed.
-//  SIN_INSERT: insert the indent in front of the line.
-//  SIN_UNDO:   save line for undo before changing it.
-//  SIN_NOMARK: don't move extmarks (because just after ml_append or something)
-//  @param size measured in spaces
-// Returns true if the line was changed.
+/// Set the indent of the current line.
+/// Leaves the cursor on the first non-blank in the line.
+/// Caller must take care of undo.
+/// "flags":
+///  SIN_CHANGED:    call changed_bytes() if the line was changed.
+///  SIN_INSERT: insert the indent in front of the line.
+///  SIN_UNDO:   save line for undo before changing it.
+///  SIN_NOMARK: don't move extmarks (because just after ml_append or something)
+///  @param size measured in spaces
+///
+/// @return  true if the line was changed.
 int set_indent(int size, int flags)
 {
-  char *p;
   char *newline;
   char *oldline;
   char *s;
-  int todo;
-  int ind_len;  // Measured in characters.
-  int line_len;
   int doit = false;
   int ind_done = 0;  // Measured in spaces.
   int tab_pad;
@@ -460,9 +449,9 @@ int set_indent(int size, int flags)
 
   // First check if there is anything to do and compute the number of
   // characters needed for the indent.
-  todo = size;
-  ind_len = 0;
-  p = oldline = get_cursor_line_ptr();
+  int todo = size;
+  int ind_len = 0;  // Measured in characters.
+  char *p = oldline = get_cursor_line_ptr();
 
   // Calculate the buffer size for the new indent, and check to see if it
   // isn't already set.
@@ -560,7 +549,7 @@ int set_indent(int size, int flags)
   } else {
     p = skipwhite(p);
   }
-  line_len = (int)strlen(p) + 1;
+  int line_len = (int)strlen(p) + 1;
 
   // If 'preserveindent' and 'expandtab' are both set keep the original
   // characters and allocate accordingly.  We will fill the rest with spaces
@@ -933,23 +922,18 @@ static void emsg_text_too_long(void)
 /// ":retab".
 void ex_retab(exarg_T *eap)
 {
-  linenr_T lnum;
   bool got_tab = false;
   int num_spaces = 0;
-  int num_tabs;
-  int len;
   int start_col = 0;                   // For start of white-space string
   int64_t start_vcol = 0;                  // For start of white-space string
-  int old_len;
   char *new_line = (char *)1;  // init to non-NULL
   colnr_T *new_vts_array = NULL;
   char *new_ts_str;  // string value of tab argument
 
-  int save_list;
   linenr_T first_line = 0;              // first changed line
   linenr_T last_line = 0;               // last changed line
 
-  save_list = curwin->w_p_list;
+  int save_list = curwin->w_p_list;
   curwin->w_p_list = 0;             // don't want list mode here
 
   new_ts_str = eap->arg;
@@ -969,7 +953,7 @@ void ex_retab(exarg_T *eap)
   } else {
     new_ts_str = xmemdupz(new_ts_str, (size_t)(eap->arg - new_ts_str));
   }
-  for (lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) {
+  for (linenr_T lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) {
     char *ptr = ml_get(lnum);
     int col = 0;
     int64_t vcol = 0;
@@ -991,8 +975,8 @@ void ex_retab(exarg_T *eap)
           // Retabulate this string of white-space
 
           // len is virtual length of white string
-          len = num_spaces = (int)(vcol - start_vcol);
-          num_tabs = 0;
+          int len = num_spaces = (int)(vcol - start_vcol);
+          int num_tabs = 0;
           if (!curbuf->b_p_et) {
             int t, s;
 
@@ -1014,7 +998,7 @@ void ex_retab(exarg_T *eap)
 
             // len is actual number of white characters used
             len = num_spaces + num_tabs;
-            old_len = (int)strlen(ptr);
+            int old_len = (int)strlen(ptr);
             const int new_len = old_len - col + start_col + len + 1;
             if (new_len <= 0 || new_len >= MAXCOL) {
               emsg_text_too_long();
@@ -1110,19 +1094,14 @@ void ex_retab(exarg_T *eap)
 /// Get indent level from 'indentexpr'.
 int get_expr_indent(void)
 {
-  int indent = -1;
-  pos_T save_pos;
-  colnr_T save_curswant;
-  int save_set_curswant;
-  int save_State;
   int use_sandbox = was_set_insecurely(curwin, kOptIndentexpr, OPT_LOCAL);
   const sctx_T save_sctx = current_sctx;
 
   // Save and restore cursor position and curswant, in case it was changed
   // * via :normal commands.
-  save_pos = curwin->w_cursor;
-  save_curswant = curwin->w_curswant;
-  save_set_curswant = curwin->w_set_curswant;
+  pos_T save_pos = curwin->w_cursor;
+  colnr_T save_curswant = curwin->w_curswant;
+  int save_set_curswant = curwin->w_set_curswant;
   set_vim_var_nr(VV_LNUM, (varnumber_T)curwin->w_cursor.lnum);
 
   if (use_sandbox) {
@@ -1134,7 +1113,7 @@ int get_expr_indent(void)
   // Need to make a copy, the 'indentexpr' option could be changed while
   // evaluating it.
   char *inde_copy = xstrdup(curbuf->b_p_inde);
-  indent = (int)eval_to_number(inde_copy);
+  int indent = (int)eval_to_number(inde_copy);
   xfree(inde_copy);
 
   if (use_sandbox) {
@@ -1146,7 +1125,7 @@ int get_expr_indent(void)
   // Restore the cursor position so that 'indentexpr' doesn't need to.
   // Pretend to be in Insert mode, allow cursor past end of line for "o"
   // command.
-  save_State = State;
+  int save_State = State;
   State = MODE_INSERT;
   curwin->w_cursor = save_pos;
   curwin->w_curswant = save_curswant;
@@ -1187,7 +1166,6 @@ int get_lisp_indent(void)
   pos_T *pos;
   pos_T paren;
   int amount;
-  char *that;
 
   // Set vi_lisp to use the vi-compatible method.
   int vi_lisp = (vim_strchr(p_cpo, CPO_LISP) != NULL);
@@ -1217,7 +1195,7 @@ int get_lisp_indent(void)
         continue;
       }
 
-      for (that = get_cursor_line_ptr(); *that != NUL; that++) {
+      for (char *that = get_cursor_line_ptr(); *that != NUL; that++) {
         if (*that == ';') {
           while (*(that + 1) != NUL) {
             that++;
@@ -1267,7 +1245,7 @@ int get_lisp_indent(void)
       curwin->w_cursor.col = pos->col;
       colnr_T col = pos->col;
 
-      that = get_cursor_line_ptr();
+      char *that = get_cursor_line_ptr();
 
       if (vi_lisp && (get_indent() == 0)) {
         amount = 2;
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 54651eb48d..44229c622b 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -597,7 +597,6 @@ static char *ins_compl_infercase_gettext(const char *str, int char_len, int comp
                                          int min_len, char **tofree)
 {
   bool has_lower = false;
-  bool was_letter = false;
 
   // Allocate wide character array for the completion and fill it.
   int *const wca = xmalloc((size_t)char_len * sizeof(*wca));
@@ -629,6 +628,7 @@ static char *ins_compl_infercase_gettext(const char *str, int char_len, int comp
   // Rule 2: No lower case, 2nd consecutive letter converted to
   // upper case.
   if (!has_lower) {
+    bool was_letter = false;
     const char *p = compl_orig_text;
     for (int i = 0; i < min_len; i++) {
       const int c = mb_ptr2char_adv(&p);
diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index 49ec245359..f8475b3e22 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -1058,7 +1058,8 @@ char *vim_strsave_escape_ks(char *p)
 /// vim_strsave_escape_ks().  Works in-place.
 void vim_unescape_ks(char *p)
 {
-  uint8_t *s = (uint8_t *)p, *d = (uint8_t *)p;
+  uint8_t *s = (uint8_t *)p;
+  uint8_t *d = (uint8_t *)p;
 
   while (*s != NUL) {
     if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER) {
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index fc2fedeaa1..4b7d2dab21 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -82,7 +82,8 @@ static int regex_match_line(lua_State *lstate)
 
   handle_T bufnr = (handle_T)luaL_checkinteger(lstate, 2);
   linenr_T rownr = (linenr_T)luaL_checkinteger(lstate, 3);
-  int start = 0, end = -1;
+  int start = 0;
+  int end = -1;
   if (narg >= 4) {
     start = (int)luaL_checkinteger(lstate, 4);
   }
@@ -177,7 +178,8 @@ int nlua_str_utfindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
     }
   }
 
-  size_t codepoints = 0, codeunits = 0;
+  size_t codepoints = 0;
+  size_t codeunits = 0;
   mb_utflen(s1, (size_t)idx, &codepoints, &codeunits);
 
   lua_pushinteger(lstate, (lua_Integer)codepoints);
diff --git a/src/nvim/lua/xdiff.c b/src/nvim/lua/xdiff.c
index 16c3aa5e11..5285c1187d 100644
--- a/src/nvim/lua/xdiff.c
+++ b/src/nvim/lua/xdiff.c
@@ -74,7 +74,8 @@ static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb,
   int *decisions = NULL;
   size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite);
 
-  int lnuma = start_a, lnumb = start_b;
+  int lnuma = start_a;
+  int lnumb = start_b;
 
   int hunkstarta = lnuma;
   int hunkstartb = lnumb;
diff --git a/src/nvim/marktree.c b/src/nvim/marktree.c
index fa5e7dcbe2..958970bba1 100644
--- a/src/nvim/marktree.c
+++ b/src/nvim/marktree.c
@@ -146,7 +146,8 @@ static inline int marktree_getp_aux(const MTNode *x, MTKey k, bool *match)
   bool dummy_match;
   bool *m = match ? match : &dummy_match;
 
-  int begin = 0, end = x->n;
+  int begin = 0;
+  int end = x->n;
   if (x->n == 0) {
     *m = false;
     return -1;
@@ -303,7 +304,8 @@ void marktree_put(MarkTree *b, MTKey key, int end_row, int end_col, bool end_rig
                                |(uint16_t)(end_right ? MT_FLAG_RIGHT_GRAVITY : 0));
     end_key.pos = (MTPos){ end_row, end_col };
     marktree_put_key(b, end_key);
-    MarkTreeIter itr[1] = { 0 }, end_itr[1] = { 0 };
+    MarkTreeIter itr[1] = { 0 };
+    MarkTreeIter end_itr[1] = { 0 };
     marktree_lookup(b, mt_lookup_key(key), itr);
     marktree_lookup(b, mt_lookup_key(end_key), end_itr);
 
@@ -684,8 +686,10 @@ uint64_t marktree_del_itr(MarkTree *b, MarkTreeIter *itr, bool rev)
 static void intersect_merge(Intersection *restrict m, Intersection *restrict x,
                             Intersection *restrict y)
 {
-  size_t xi = 0, yi = 0;
-  size_t xn = 0, yn = 0;
+  size_t xi = 0;
+  size_t yi = 0;
+  size_t xn = 0;
+  size_t yn = 0;
   while (xi < kv_size(*x) && yi < kv_size(*y)) {
     if (kv_A(*x, xi) == kv_A(*y, yi)) {
       // TODO(bfredl): kvi_pushp is actually quite complex, break out kvi_resize() to a function?
@@ -717,8 +721,10 @@ static void intersect_merge(Intersection *restrict m, Intersection *restrict x,
 static void intersect_mov(Intersection *restrict x, Intersection *restrict y,
                           Intersection *restrict w, Intersection *restrict d)
 {
-  size_t wi = 0, yi = 0;
-  size_t wn = 0, yn = 0;
+  size_t wi = 0;
+  size_t yi = 0;
+  size_t wn = 0;
+  size_t yn = 0;
   size_t xi = 0;
   while (wi < kv_size(*w) || xi < kv_size(*x)) {
     if (wi < kv_size(*w) && (xi >= kv_size(*x) || kv_A(*x, xi) >= kv_A(*w, wi))) {
@@ -810,7 +816,8 @@ bool intersect_mov_test(const uint64_t *x, size_t nx, const uint64_t *y, size_t
 /// intersection: i = x & y
 static void intersect_common(Intersection *i, Intersection *x, Intersection *y)
 {
-  size_t xi = 0, yi = 0;
+  size_t xi = 0;
+  size_t yi = 0;
   while (xi < kv_size(*x) && yi < kv_size(*y)) {
     if (kv_A(*x, xi) == kv_A(*y, yi)) {
       kvi_push(*i, kv_A(*x, xi));
@@ -827,7 +834,8 @@ static void intersect_common(Intersection *i, Intersection *x, Intersection *y)
 // inplace union: x |= y
 static void intersect_add(Intersection *x, Intersection *y)
 {
-  size_t xi = 0, yi = 0;
+  size_t xi = 0;
+  size_t yi = 0;
   while (xi < kv_size(*x) && yi < kv_size(*y)) {
     if (kv_A(*x, xi) == kv_A(*y, yi)) {
       xi++;
@@ -854,7 +862,8 @@ static void intersect_add(Intersection *x, Intersection *y)
 // inplace asymmetric difference: x &= ~y
 static void intersect_sub(Intersection *restrict x, Intersection *restrict y)
 {
-  size_t xi = 0, yi = 0;
+  size_t xi = 0;
+  size_t yi = 0;
   size_t xn = 0;
   while (xi < kv_size(*x) && yi < kv_size(*y)) {
     if (kv_A(*x, xi) == kv_A(*y, yi)) {
@@ -898,7 +907,8 @@ static void bubble_up(MTNode *x)
 
 static MTNode *merge_node(MarkTree *b, MTNode *p, int i)
 {
-  MTNode *x = p->ptr[i], *y = p->ptr[i + 1];
+  MTNode *x = p->ptr[i];
+  MTNode *y = p->ptr[i + 1];
   Intersection m;
   kvi_init(m);
 
@@ -975,7 +985,8 @@ void kvi_move(Intersection *dest, Intersection *src)
 // key inside x, if x is the first leaf)
 static void pivot_right(MarkTree *b, MTPos p_pos, MTNode *p, const int i)
 {
-  MTNode *x = p->ptr[i], *y = p->ptr[i + 1];
+  MTNode *x = p->ptr[i];
+  MTNode *y = p->ptr[i + 1];
   memmove(&y->key[1], y->key, (size_t)y->n * sizeof(MTKey));
   if (y->level) {
     memmove(&y->ptr[1], y->ptr, ((size_t)y->n + 1) * sizeof(MTNode *));
@@ -1040,7 +1051,8 @@ static void pivot_right(MarkTree *b, MTPos p_pos, MTNode *p, const int i)
 
 static void pivot_left(MarkTree *b, MTPos p_pos, MTNode *p, int i)
 {
-  MTNode *x = p->ptr[i], *y = p->ptr[i + 1];
+  MTNode *x = p->ptr[i];
+  MTNode *y = p->ptr[i + 1];
 
   // reverse from how we "always" do it. but pivot_left
   // is just the inverse of pivot_right, so reverse it literally.
@@ -1603,7 +1615,8 @@ static void swap_keys(MarkTree *b, MarkTreeIter *itr1, MarkTreeIter *itr2, Damag
 
 static int damage_cmp(const void *s1, const void *s2)
 {
-  Damage *d1 = (Damage *)s1, *d2 = (Damage *)s2;
+  Damage *d1 = (Damage *)s1;
+  Damage *d2 = (Damage *)s2;
   assert(d1->id != d2->id);
   return d1->id > d2->id ? 1 : -1;
 }
@@ -1619,7 +1632,8 @@ bool marktree_splice(MarkTree *b, int32_t start_line, int start_col, int old_ext
   bool same_line = old_extent.row == 0 && new_extent.row == 0;
   unrelative(start, &old_extent);
   unrelative(start, &new_extent);
-  MarkTreeIter itr[1] = { 0 }, enditr[1] = { 0 };
+  MarkTreeIter itr[1] = { 0 };
+  MarkTreeIter enditr[1] = { 0 };
 
   MTPos oldbase[MT_MAX_DEPTH] = { 0 };
 
@@ -1824,7 +1838,8 @@ past_continue_same_node:
 void marktree_move_region(MarkTree *b, int start_row, colnr_T start_col, int extent_row,
                           colnr_T extent_col, int new_row, colnr_T new_col)
 {
-  MTPos start = { start_row, start_col }, size = { extent_row, extent_col };
+  MTPos start = { start_row, start_col };
+  MTPos size = { extent_row, extent_col };
   MTPos end = size;
   unrelative(start, &end);
   MarkTreeIter itr[1] = { 0 };
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index f2883cc5c7..a992bf3cd8 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1422,7 +1422,8 @@ int utf16_to_utf8(const wchar_t *utf16, int utf16len, char **utf8)
 void mb_utflen(const char *s, size_t len, size_t *codepoints, size_t *codeunits)
   FUNC_ATTR_NONNULL_ALL
 {
-  size_t count = 0, extra = 0;
+  size_t count = 0;
+  size_t extra = 0;
   size_t clen;
   for (size_t i = 0; i < len; i += clen) {
     clen = (size_t)utf_ptr2len_len(s + i, (int)(len - i));
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index a0786391b5..feb13384be 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -286,7 +286,8 @@ void strchrsub(char *str, char c, char x)
 void memchrsub(void *data, char c, char x, size_t len)
   FUNC_ATTR_NONNULL_ALL
 {
-  char *p = data, *end = (char *)data + len;
+  char *p = data;
+  char *end = (char *)data + len;
   while ((p = memchr(p, c, (size_t)(end - p)))) {
     *p++ = x;
   }
@@ -321,7 +322,8 @@ size_t memcnt(const void *data, char c, size_t len)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
 {
   size_t cnt = 0;
-  const char *ptr = data, *end = ptr + len;
+  const char *ptr = data;
+  const char *end = ptr + len;
   while ((ptr = memchr(ptr, c, (size_t)(end - ptr))) != NULL) {
     cnt++;
     ptr++;  // Skip the instance of c.
diff --git a/src/nvim/move.c b/src/nvim/move.c
index bbc3d792c0..891aa8f5ce 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -1037,7 +1037,9 @@ void curs_columns(win_T *wp, int may_scroll)
 void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp, int *ecolp,
                        bool local)
 {
-  colnr_T scol = 0, ccol = 0, ecol = 0;
+  colnr_T scol = 0;
+  colnr_T ccol = 0;
+  colnr_T ecol = 0;
   int row = 0;
   colnr_T coloff = 0;
   bool visible_row = false;
@@ -1129,7 +1131,9 @@ void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     pos.col = 0;
   }
   int row = 0;
-  int scol = 0, ccol = 0, ecol = 0;
+  int scol = 0;
+  int ccol = 0;
+  int ecol = 0;
   textpos2screenpos(wp, &pos, &row, &scol, &ccol, &ecol, false);
 
   tv_dict_add_nr(dict, S_LEN("row"), row);
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 16aa46e97d..71c2c7930e 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -390,7 +390,8 @@ static void shift_block(oparg_T *oap, int amount)
     bd.start_vcol = cts.cts_vcol;
     clear_chartabsize_arg(&cts);
 
-    int tabs = 0, spaces = 0;
+    int tabs = 0;
+    int spaces = 0;
     // OK, now total=all the VWS reqd, and textstart points at the 1st
     // non-ws char in the block.
     if (!curbuf->b_p_et) {
@@ -1891,7 +1892,8 @@ static int op_replace(oparg_T *oap, int c)
       size_t after_p_len = 0;
       int col = oldlen - bd.textcol - bd.textlen + 1;
       assert(col >= 0);
-      int newrows = 0, newcols = 0;
+      int newrows = 0;
+      int newcols = 0;
       if (had_ctrl_v_cr || (c != '\r' && c != '\n')) {
         // strlen(newp) at this point
         int newp_len = bd.textcol + bd.startspaces;
@@ -2040,11 +2042,9 @@ void op_tilde(oparg_T *oap)
   pos_T pos = oap->start;
   if (oap->motion_type == kMTBlockWise) {  // Visual block mode
     for (; pos.lnum <= oap->end.lnum; pos.lnum++) {
-      int one_change;
-
       block_prep(oap, &bd, pos.lnum, false);
       pos.col = bd.textcol;
-      one_change = swapchars(oap->op_type, &pos, bd.textlen);
+      int one_change = swapchars(oap->op_type, &pos, bd.textlen);
       did_change |= one_change;
     }
     if (did_change) {
@@ -2636,7 +2636,8 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
       break;
 
     case kMTCharWise: {
-      colnr_T startcol = 0, endcol = MAXCOL;
+      colnr_T startcol = 0;
+      colnr_T endcol = MAXCOL;
       int is_oneChar = false;
       colnr_T cs, ce;
       char *p = ml_get(lnum);
@@ -2685,8 +2686,7 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
       if (endcol == MAXCOL) {
         endcol = (colnr_T)strlen(p);
       }
-      if (startcol > endcol
-          || is_oneChar) {
+      if (startcol > endcol || is_oneChar) {
         bd.textlen = 0;
       } else {
         bd.textlen = endcol - startcol + oap->inclusive;
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 9ca8615467..41facb86eb 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -2815,7 +2815,8 @@ static const char *set_chars_option(win_T *wp, const char *value, const bool is_
         if (c1 == 0 || char2cells(c1) > 1) {
           return e_invarg;
         }
-        int c2 = 0, c3 = 0;
+        int c2 = 0;
+        int c3 = 0;
         if (tab[i].cp == &lcs_chars.tab2) {
           if (*s == NUL) {
             return e_invarg;
diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index e096749ce3..5b759e9d1e 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -415,7 +415,8 @@ static unsigned handle_mouse_event(const char **ptr, uint8_t *buf, unsigned bufs
 size_t input_enqueue_mouse(int code, uint8_t modifier, int grid, int row, int col)
 {
   modifier |= check_multiclick(code, grid, row, col);
-  uint8_t buf[7], *p = buf;
+  uint8_t buf[7];
+  uint8_t *p = buf;
   if (modifier) {
     p[0] = K_SPECIAL;
     p[1] = KS_MODIFIER;
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index a0401f3a24..26e3171c5b 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -671,7 +671,8 @@ char *shell_argv_to_str(char **const argv)
 int os_call_shell(char *cmd, ShellOpts opts, char *extra_args)
 {
   DynamicBuffer input = DYNAMIC_BUFFER_INIT;
-  char *output = NULL, **output_ptr = NULL;
+  char *output = NULL;
+  char **output_ptr = NULL;
   int current_state = State;
   bool forward_output = true;
 
@@ -1123,7 +1124,8 @@ static void out_data_ring(char *output, size_t size)
 static void out_data_append_to_screen(char *output, size_t *count, bool eof)
   FUNC_ATTR_NONNULL_ALL
 {
-  char *p = output, *end = output + *count;
+  char *p = output;
+  char *end = output + *count;
   while (p < end) {
     if (*p == '\n' || *p == '\r' || *p == TAB || *p == BELL) {
       msg_putchar_attr((uint8_t)(*p), 0);
@@ -1236,7 +1238,8 @@ static size_t word_length(const char *str)
 /// before we finish writing.
 static void read_input(DynamicBuffer *buf)
 {
-  size_t written = 0, len = 0;
+  size_t written = 0;
+  size_t len = 0;
   linenr_T lnum = curbuf->b_op_start.lnum;
   char *lp = ml_get(lnum);
 
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 169909ea56..2a5777a774 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -1358,9 +1358,13 @@ int vim_vsnprintf_typval(char *str, size_t str_m, const char *fmt, va_list ap_st
       assert(n <= SIZE_MAX - str_l);
       str_l += n;
     } else {
-      size_t min_field_width = 0, precision = 0;
-      int zero_padding = 0, precision_specified = 0, justify_left = 0;
-      int alternate_form = 0, force_sign = 0;
+      size_t min_field_width = 0;
+      size_t precision = 0;
+      int zero_padding = 0;
+      int precision_specified = 0;
+      int justify_left = 0;
+      int alternate_form = 0;
+      int force_sign = 0;
 
       // if both ' ' and '+' flags appear, ' ' flag should be ignored
       int space_for_positive = 1;
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index c26e2a2259..da6bf134de 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -279,13 +279,12 @@ void terminal_open(Terminal **termpp, buf_T *buf, TerminalOptions opts)
   // - g:terminal_color_{NUM}
   // - the VTerm instance
   for (int i = 0; i < 16; i++) {
-    RgbValue color_val = -1;
     char var[64];
     snprintf(var, sizeof(var), "terminal_color_%d", i);
     char *name = get_config_string(var);
     if (name) {
       int dummy;
-      color_val = name_to_color(name, &dummy);
+      RgbValue color_val = name_to_color(name, &dummy);
       xfree(name);
 
       if (color_val != -1) {
@@ -390,7 +389,8 @@ void terminal_check_size(Terminal *term)
 
   int curwidth, curheight;
   vterm_get_size(term->vt, &curheight, &curwidth);
-  uint16_t width = 0, height = 0;
+  uint16_t width = 0;
+  uint16_t height = 0;
 
   // Check if there is a window that displays the terminal and find the maximum width and height.
   // Skip the autocommand window which isn't actually displayed.
@@ -1430,7 +1430,9 @@ static void mouse_action(Terminal *term, int button, int row, int col, bool pres
 // terminal should lose focus
 static bool send_mouse_event(Terminal *term, int c)
 {
-  int row = mouse_row, col = mouse_col, grid = mouse_grid;
+  int row = mouse_row;
+  int col = mouse_col;
+  int grid = mouse_grid;
   win_T *mouse_win = mouse_find_win(&grid, &row, &col);
   if (mouse_win == NULL) {
     goto end;
diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c
index 496c192b95..ba4069ecf4 100644
--- a/src/nvim/tui/tui.c
+++ b/src/nvim/tui/tui.c
@@ -1223,8 +1223,10 @@ void tui_grid_scroll(TUIData *tui, Integer g, Integer startrow, Integer endrow,
                      Integer endcol, Integer rows, Integer cols FUNC_ATTR_UNUSED)
 {
   UGrid *grid = &tui->grid;
-  int top = (int)startrow, bot = (int)endrow - 1;
-  int left = (int)startcol, right = (int)endcol - 1;
+  int top = (int)startrow;
+  int bot = (int)endrow - 1;
+  int left = (int)startcol;
+  int right = (int)endcol - 1;
 
   bool fullwidth = left == 0 && right == tui->width - 1;
   tui->scroll_region_is_full_screen = fullwidth
@@ -1565,7 +1567,8 @@ static void invalidate(TUIData *tui, int top, int bot, int left, int right)
 /// application (i.e., the host terminal).
 void tui_guess_size(TUIData *tui)
 {
-  int width = 0, height = 0;
+  int width = 0;
+  int height = 0;
 
   // 1 - try from a system call(ioctl/TIOCGWINSZ on unix)
   if (tui->out_isatty
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 1f94e4da63..48cf0489b7 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -198,7 +198,8 @@ void ui_refresh(void)
     return;
   }
 
-  int width = INT_MAX, height = INT_MAX;
+  int width = INT_MAX;
+  int height = INT_MAX;
   bool ext_widgets[kUIExtCount];
   for (UIExtension i = 0; (int)i < kUIExtCount; i++) {
     ext_widgets[i] = true;
diff --git a/src/nvim/ui_client.c b/src/nvim/ui_client.c
index 5c9eeaabdf..fdd859ba29 100644
--- a/src/nvim/ui_client.c
+++ b/src/nvim/ui_client.c
@@ -203,7 +203,9 @@ void ui_client_event_grid_line(Array args)
 
 void ui_client_event_raw_line(GridLineEvent *g)
 {
-  int grid = g->args[0], row = g->args[1], startcol = g->args[2];
+  int grid = g->args[0];
+  int row = g->args[1];
+  int startcol = g->args[2];
   Integer endcol = startcol + g->coloff;
   Integer clearcol = endcol + g->clear_width;
   LineFlags lineflags = g->wrap ? kLineFlagWrap : 0;
diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c
index c4078d6f63..baad8f3c29 100644
--- a/src/nvim/ui_compositor.c
+++ b/src/nvim/ui_compositor.c
@@ -305,7 +305,8 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag
   startcol = MAX(startcol, 0);
   // in case we start on the right half of a double-width char, we need to
   // check the left half. But skip it in output if it wasn't doublewidth.
-  int skipstart = 0, skipend = 0;
+  int skipstart = 0;
+  int skipend = 0;
   if (startcol > 0 && (flags & kLineFlagInvalid)) {
     startcol--;
     skipstart = 1;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index fd3bb41de0..7c44f0de62 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -963,12 +963,11 @@ static u_header_T *unserialize_uhp(bufinfo_T *bi, const char *file_name)
   }
 
   // Unserialize all extmark undo information
-  ExtmarkUndoObject *extup;
   kv_init(uhp->uh_extmark);
 
   while ((c = undo_read_2c(bi)) == UF_ENTRY_MAGIC) {
     bool error = false;
-    extup = unserialize_extmark(bi, &error, file_name);
+    ExtmarkUndoObject *extup = unserialize_extmark(bi, &error, file_name);
     if (error) {
       kv_destroy(uhp->uh_extmark);
       xfree(extup);
@@ -1553,7 +1552,9 @@ void u_read_undo(char *name, const uint8_t *hash, const char *orig_name FUNC_ATT
   // We have put all of the headers into a table. Now we iterate through the
   // table and swizzle each sequence number we have stored in uh_*_seq into
   // a pointer corresponding to the header with that sequence number.
-  int16_t old_idx = -1, new_idx = -1, cur_idx = -1;
+  int16_t old_idx = -1;
+  int16_t new_idx = -1;
+  int16_t cur_idx = -1;
   for (int i = 0; i < num_head; i++) {
     u_header_T *uhp = uhp_table[i];
     if (uhp == NULL) {
diff --git a/src/nvim/window.c b/src/nvim/window.c
index fe9509548f..929a06350b 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -759,7 +759,8 @@ void ui_ext_win_position(win_T *wp, bool validate)
   FloatConfig c = wp->w_float_config;
   if (!c.external) {
     ScreenGrid *grid = &default_grid;
-    Float row = c.row, col = c.col;
+    Float row = c.row;
+    Float col = c.col;
     if (c.relative == kFloatRelativeWindow) {
       Error dummy = ERROR_INIT;
       win_T *win = find_window_by_handle(c.window, &dummy);
@@ -771,7 +772,8 @@ void ui_ext_win_position(win_T *wp, bool validate)
           ui_ext_win_position(win, validate);
         }
         grid = &win->w_grid;
-        int row_off = 0, col_off = 0;
+        int row_off = 0;
+        int col_off = 0;
         grid_adjust(&grid, &row_off, &col_off);
         row += row_off;
         col += col_off;
@@ -5463,7 +5465,8 @@ void may_trigger_win_scrolled_resized(void)
   }
 
   int size_count = 0;
-  win_T *first_scroll_win = NULL, *first_size_win = NULL;
+  win_T *first_scroll_win = NULL;
+  win_T *first_size_win = NULL;
   int cwsr = check_window_scroll_resize(&size_count,
                                         &first_scroll_win, &first_size_win,
                                         NULL, NULL);
@@ -7404,7 +7407,8 @@ void win_get_tabwin(handle_T id, int *tabnr, int *winnr)
   *tabnr = 0;
   *winnr = 0;
 
-  int tnum = 1, wnum = 1;
+  int tnum = 1;
+  int wnum = 1;
   FOR_ALL_TABS(tp) {
     FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
       if (wp->handle == id) {
diff --git a/src/nvim/winfloat.c b/src/nvim/winfloat.c
index 4efff3cfab..87069d5682 100644
--- a/src/nvim/winfloat.c
+++ b/src/nvim/winfloat.c
@@ -146,7 +146,9 @@ void win_config_float(win_T *wp, FloatConfig fconfig)
     fconfig.col += curwin->w_wcol;
     fconfig.window = curwin->handle;
   } else if (fconfig.relative == kFloatRelativeMouse) {
-    int row = mouse_row, col = mouse_col, grid = mouse_grid;
+    int row = mouse_row;
+    int col = mouse_col;
+    int grid = mouse_grid;
     win_T *mouse_win = mouse_find_win(&grid, &row, &col);
     if (mouse_win != NULL) {
       fconfig.relative = kFloatRelativeWindow;
@@ -197,7 +199,8 @@ void win_config_float(win_T *wp, FloatConfig fconfig)
       row += parent->w_winrow;
       col += parent->w_wincol;
       ScreenGrid *grid = &parent->w_grid;
-      int row_off = 0, col_off = 0;
+      int row_off = 0;
+      int col_off = 0;
       grid_adjust(&grid, &row_off, &col_off);
       row += row_off;
       col += col_off;