Introduce ga_append_via_ptr() and GA_APPEND_VIA_PTR()

Similar to GA_APPEND(). Replaces this pattern:

    ga_grow(&ga, 1);
    item_type *p = ((item_type *)ga.ga_data) + ga.ga_len;
    p->field1 = v1;
    p->field2 = v2;
    ga.ga_len++;

8 files changed, 82 insertions, 111 deletions

diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index a0834e9da9..396aac3ba9 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1619,12 +1619,10 @@ void putdigraph(char_u *str)
 
     // Add a new digraph to the table.
     if (i == user_digraphs.ga_len) {
-      ga_grow(&user_digraphs, 1);
-      dp = (digr_T *)user_digraphs.ga_data + user_digraphs.ga_len;
+      dp = GA_APPEND_VIA_PTR(digr_T, &user_digraphs);
       dp->char1 = char1;
       dp->char2 = char2;
       dp->result = n;
-      ++user_digraphs.ga_len;
     }
   }
 }
@@ -1772,7 +1770,6 @@ void ex_loadkeymap(exarg_T *eap)
   char_u *line;
   char_u *p;
   char_u *s;
-  kmap_T *kp;
 
 #define KMAP_LLEN 200  // max length of "to" and "from" together
   char_u buf[KMAP_LLEN + 11];
@@ -1803,8 +1800,7 @@ void ex_loadkeymap(exarg_T *eap)
     p = skipwhite(line);
 
     if ((*p != '"') && (*p != NUL)) {
-      ga_grow(&curbuf->b_kmap_ga, 1);
-      kp = (kmap_T *)curbuf->b_kmap_ga.ga_data + curbuf->b_kmap_ga.ga_len;
+      kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga);
       s = skiptowhite(p);
       kp->from = vim_strnsave(p, (int)(s - p));
       p = skipwhite(s);
@@ -1819,8 +1815,7 @@ void ex_loadkeymap(exarg_T *eap)
         }
         free(kp->from);
         free(kp->to);
-      } else {
-        ++curbuf->b_kmap_ga.ga_len;
+        --curbuf->b_kmap_ga.ga_len;
       }
     }
     free(line);
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 4e0f5c9137..15967f484b 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -5290,8 +5290,7 @@ list_join_inner (
     len = (int)STRLEN(s);
     sumlen += len;
 
-    ga_grow(join_gap, 1);
-    p = ((join_T *)join_gap->ga_data) + (join_gap->ga_len++);
+    p = GA_APPEND_VIA_PTR(join_T, join_gap);
     if (tofree != NULL || s != numbuf) {
       p->s = s;
       p->tofree = tofree;
@@ -10218,11 +10217,9 @@ static void f_inputrestore(typval_T *argvars, typval_T *rettv)
  */
 static void f_inputsave(typval_T *argvars, typval_T *rettv)
 {
-  /* Add an entry to the stack of typeahead storage. */
-  ga_grow(&ga_userinput, 1);
-  save_typeahead((tasave_T *)(ga_userinput.ga_data)
-          + ga_userinput.ga_len);
-  ++ga_userinput.ga_len;
+  // Add an entry to the stack of typeahead storage.
+  tasave_T *p = GA_APPEND_VIA_PTR(tasave_T, &ga_userinput);
+  save_typeahead(p);
 }
 
 /*
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 701a51799f..963fd33371 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -1037,10 +1037,9 @@ static char_u *get_loop_line(int c, void *cookie, int indent)
  */
 static void store_loop_line(garray_T *gap, char_u *line)
 {
-  ga_grow(gap, 1);
-  ((wcmd_T *)(gap->ga_data))[gap->ga_len].line = vim_strsave(line);
-  ((wcmd_T *)(gap->ga_data))[gap->ga_len].lnum = sourcing_lnum;
-  ++gap->ga_len;
+  wcmd_T *p = GA_APPEND_VIA_PTR(wcmd_T, gap);
+  p->line = vim_strsave(line);
+  p->lnum = sourcing_lnum;
 }
 
 /*
diff --git a/src/nvim/garray.h b/src/nvim/garray.h
index ed5e2dbada..5a90da21c2 100644
--- a/src/nvim/garray.h
+++ b/src/nvim/garray.h
@@ -1,6 +1,8 @@
 #ifndef NVIM_GARRAY_H
 #define NVIM_GARRAY_H
 
+#include "nvim/log.h"
+
 /// Structure used for growing arrays.
 /// This is used to store information that only grows, is deleted all at
 /// once, and needs to be accessed by index.  See ga_clear() and ga_grow().
@@ -22,7 +24,20 @@ typedef struct growarray {
     ((item_type *)(gap)->ga_data)[(gap)->ga_len++] = (item);               \
   } while (0)
 
+#define GA_APPEND_VIA_PTR(item_type, gap) \
+  ga_append_via_ptr(gap, sizeof(item_type))
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "garray.h.generated.h"
 #endif
+
+static inline void *ga_append_via_ptr(garray_T *gap, size_t item_size)
+{
+  if ((int)item_size != gap->ga_itemsize) {
+    ELOG("wrong item size in garray(%d), should be %d", item_size);
+  }
+  ga_grow(gap, 1);
+  return ((char *)gap->ga_data) + (item_size * (size_t)gap->ga_len++);
+}
+
 #endif  // NVIM_GARRAY_H
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index ad6bcc82da..ab5c1569dc 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -1444,7 +1444,6 @@ static garray_T menutrans_ga = GA_EMPTY_INIT_VALUE;
 void ex_menutranslate(exarg_T *eap)
 {
   char_u              *arg = eap->arg;
-  menutrans_T         *tp;
   char_u              *from, *from_noamp, *to;
 
   if (menutrans_ga.ga_itemsize == 0)
@@ -1454,7 +1453,7 @@ void ex_menutranslate(exarg_T *eap)
    * ":menutrans clear": clear all translations.
    */
   if (STRNCMP(arg, "clear", 5) == 0 && ends_excmd(*skipwhite(arg + 5))) {
-    tp = (menutrans_T *)menutrans_ga.ga_data;
+    menutrans_T *tp = (menutrans_T *)menutrans_ga.ga_data;
     for (int i = 0; i < menutrans_ga.ga_len; ++i) {
       free(tp[i].from);
       free(tp[i].from_noamp);
@@ -1473,8 +1472,6 @@ void ex_menutranslate(exarg_T *eap)
     if (arg == to)
       EMSG(_(e_invarg));
     else {
-      ga_grow(&menutrans_ga, 1);
-      tp = (menutrans_T *)menutrans_ga.ga_data;
       from = vim_strsave(from);
       from_noamp = menu_text(from, NULL, NULL);
       to = vim_strnsave(to, (int)(arg - to));
@@ -1483,10 +1480,10 @@ void ex_menutranslate(exarg_T *eap)
         menu_translate_tab_and_shift(to);
         menu_unescape_name(from);
         menu_unescape_name(to);
-        tp[menutrans_ga.ga_len].from = from;
-        tp[menutrans_ga.ga_len].from_noamp = from_noamp;
-        tp[menutrans_ga.ga_len].to = to;
-        ++menutrans_ga.ga_len;
+        menutrans_T* tp = GA_APPEND_VIA_PTR(menutrans_T, &menutrans_ga);
+        tp->from = from;
+        tp->from_noamp = from_noamp;
+        tp->to = to;
       } else {
         free(from);
         free(from_noamp);
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index 29f090c6b7..0ead83e0d4 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -4177,7 +4177,6 @@ regmatch (
         case BACK:
         {
           int i;
-          backpos_T       *bp;
 
           /*
            * When we run into BACK we need to check if we don't keep
@@ -4187,17 +4186,13 @@ regmatch (
            * The positions are stored in "backpos" and found by the
            * current value of "scan", the position in the RE program.
            */
-          bp = (backpos_T *)backpos.ga_data;
+          backpos_T *bp = (backpos_T *)backpos.ga_data;
           for (i = 0; i < backpos.ga_len; ++i)
             if (bp[i].bp_scan == scan)
               break;
           if (i == backpos.ga_len) {
-            /* First time at this BACK, make room to store the pos. */
-            ga_grow(&backpos, 1);
-            /* get "ga_data" again, it may have changed */
-            bp = (backpos_T *)backpos.ga_data;
-            bp[i].bp_scan = scan;
-            ++backpos.ga_len;
+            backpos_T *p = GA_APPEND_VIA_PTR(backpos_T, &backpos);
+            p->bp_scan = scan;
           } else if (reg_save_equal(&bp[i].bp_pos))
             /* Still at same position as last time, fail. */
             status = RA_NOMATCH;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 711f892d16..2f88c2d523 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -3335,7 +3335,6 @@ static int init_syl_tab(slang_T *slang)
   char_u      *p;
   char_u      *s;
   int l;
-  syl_item_T  *syl;
 
   ga_init(&slang->sl_syl_items, sizeof(syl_item_T), 4);
   p = vim_strchr(slang->sl_syllable, '/');
@@ -3351,9 +3350,8 @@ static int init_syl_tab(slang_T *slang)
       l = (int)(p - s);
     if (l >= SY_MAXLEN)
       return SP_FORMERROR;
-    ga_grow(&slang->sl_syl_items, 1);
-    syl = ((syl_item_T *)slang->sl_syl_items.ga_data)
-          + slang->sl_syl_items.ga_len++;
+
+    syl_item_T *syl = GA_APPEND_VIA_PTR(syl_item_T, &slang->sl_syl_items);
     STRLCPY(syl->sy_chars, s, l + 1);
     syl->sy_len = l;
   }
@@ -3835,10 +3833,10 @@ char_u *did_set_spelllang(win_T *wp)
         }
 
         if (region_mask != 0) {
-          ga_grow(&ga, 1);
-          LANGP_ENTRY(ga, ga.ga_len)->lp_slang = slang;
-          LANGP_ENTRY(ga, ga.ga_len)->lp_region = region_mask;
-          ++ga.ga_len;
+          langp_T *p = GA_APPEND_VIA_PTR(langp_T, &ga);
+          p->lp_slang = slang;
+          p->lp_region = region_mask;
+
           use_midword(slang, wp);
           if (slang->sl_nobreak)
             nobreak = TRUE;
@@ -3896,7 +3894,6 @@ char_u *did_set_spelllang(win_T *wp)
         slang->sl_nobreak = TRUE;
     }
     if (slang != NULL) {
-      ga_grow(&ga, 1);
       region_mask = REGION_ALL;
       if (use_region != NULL && !dont_use_region) {
         // find region in sl_regions
@@ -3909,11 +3906,12 @@ char_u *did_set_spelllang(win_T *wp)
       }
 
       if (region_mask != 0) {
-        LANGP_ENTRY(ga, ga.ga_len)->lp_slang = slang;
-        LANGP_ENTRY(ga, ga.ga_len)->lp_sallang = NULL;
-        LANGP_ENTRY(ga, ga.ga_len)->lp_replang = NULL;
-        LANGP_ENTRY(ga, ga.ga_len)->lp_region = region_mask;
-        ++ga.ga_len;
+        langp_T *p = GA_APPEND_VIA_PTR(langp_T, &ga);
+        p->lp_slang = slang;
+        p->lp_sallang = NULL;
+        p->lp_replang = NULL;
+        p->lp_region = region_mask;
+
         use_midword(slang, wp);
       }
     }
@@ -4851,16 +4849,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                   break;
               }
               if (idx < 0) {
-                ga_grow(&spin->si_prefcond, 1);
                 // Not found, add a new condition.
-                idx = spin->si_prefcond.ga_len++;
-                pp = ((char_u **)spin->si_prefcond.ga_data)
-                     + idx;
-                if (aff_entry->ae_cond == NULL)
-                  *pp = NULL;
-                else
-                  *pp = getroom_save(spin,
-                      aff_entry->ae_cond);
+                idx = spin->si_prefcond.ga_len;
+                pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
+                *pp = (aff_entry->ae_cond == NULL) ?
+                  NULL : getroom_save(spin, aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
@@ -5328,16 +5321,13 @@ static int str_equal(char_u *s1, char_u *s2)
 // They are stored case-folded.
 static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from, char_u *to)
 {
-  fromto_T    *ftp;
   char_u word[MAXWLEN];
 
-  ga_grow(gap, 1);
-  ftp = ((fromto_T *)gap->ga_data) + gap->ga_len;
+  fromto_T *ftp = GA_APPEND_VIA_PTR(fromto_T, gap);
   (void)spell_casefold(from, (int)STRLEN(from), word, MAXWLEN);
   ftp->ft_from = getroom_save(spin, word);
   (void)spell_casefold(to, (int)STRLEN(to), word, MAXWLEN);
   ftp->ft_to = getroom_save(spin, word);
-  ++gap->ga_len;
 }
 
 // Convert a boolean argument in a SAL line to TRUE or FALSE;
@@ -11503,9 +11493,8 @@ add_suggestion (
   }
 
   if (i < 0) {
-    ga_grow(gap, 1);
     // Add a suggestion.
-    stp = &SUG(*gap, gap->ga_len);
+    stp = GA_APPEND_VIA_PTR(suggest_T, gap);
     stp->st_word = vim_strnsave(goodword, goodlen);
     stp->st_wordlen = goodlen;
     stp->st_score = score;
@@ -11513,7 +11502,6 @@ add_suggestion (
     stp->st_had_bonus = had_bonus;
     stp->st_orglen = badlen;
     stp->st_slang = slang;
-    ++gap->ga_len;
 
     // If we have too many suggestions now, sort the list and keep
     // the best suggestions.
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 945172564b..0ce8d6e16f 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -2485,10 +2485,9 @@ update_si_end (
  */
 static void push_current_state(int idx)
 {
-  ga_grow(&current_state, 1);
-  memset(&CUR_STATE(current_state.ga_len), 0, sizeof(stateitem_T));
-  CUR_STATE(current_state.ga_len).si_idx = idx;
-  ++current_state.ga_len;
+  stateitem_T *p = GA_APPEND_VIA_PTR(stateitem_T, &current_state);
+  memset(p, 0, sizeof(*p));
+  p->si_idx = idx;
 }
 
 /*
@@ -4279,28 +4278,26 @@ syn_cmd_match (
     if (!ends_excmd(*rest) || eap->skip)
       rest = NULL;
     else {
-      ga_grow(&curwin->w_s->b_syn_patterns, 1);
       if ((syn_id = syn_check_group(arg, (int)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
         /*
          * Store the pattern in the syn_items list
          */
-        int idx = curwin->w_s->b_syn_patterns.ga_len;
-        SYN_ITEMS(curwin->w_s)[idx] = item;
-        SYN_ITEMS(curwin->w_s)[idx].sp_syncing = syncing;
-        SYN_ITEMS(curwin->w_s)[idx].sp_type = SPTYPE_MATCH;
-        SYN_ITEMS(curwin->w_s)[idx].sp_syn.id = syn_id;
-        SYN_ITEMS(curwin->w_s)[idx].sp_syn.inc_tag = current_syn_inc_tag;
-        SYN_ITEMS(curwin->w_s)[idx].sp_flags = syn_opt_arg.flags;
-        SYN_ITEMS(curwin->w_s)[idx].sp_sync_idx = sync_idx;
-        SYN_ITEMS(curwin->w_s)[idx].sp_cont_list = syn_opt_arg.cont_list;
-        SYN_ITEMS(curwin->w_s)[idx].sp_syn.cont_in_list =
-          syn_opt_arg.cont_in_list;
-        SYN_ITEMS(curwin->w_s)[idx].sp_cchar = conceal_char;
+        synpat_T *spp = GA_APPEND_VIA_PTR(synpat_T,
+                                          &curwin->w_s->b_syn_patterns);
+        *spp = item;
+        spp->sp_syncing = syncing;
+        spp->sp_type = SPTYPE_MATCH;
+        spp->sp_syn.id = syn_id;
+        spp->sp_syn.inc_tag = current_syn_inc_tag;
+        spp->sp_flags = syn_opt_arg.flags;
+        spp->sp_sync_idx = sync_idx;
+        spp->sp_cont_list = syn_opt_arg.cont_list;
+        spp->sp_syn.cont_in_list = syn_opt_arg.cont_in_list;
+        spp->sp_cchar = conceal_char;
         if (syn_opt_arg.cont_in_list != NULL)
           curwin->w_s->b_syn_containedin = TRUE;
-        SYN_ITEMS(curwin->w_s)[idx].sp_next_list = syn_opt_arg.next_list;
-        ++curwin->w_s->b_syn_patterns.ga_len;
+        spp->sp_next_list = syn_opt_arg.next_list;
 
         /* remember that we found a match for syncing on */
         if (syn_opt_arg.flags & (HL_SYNC_HERE|HL_SYNC_THERE))
@@ -4755,16 +4752,12 @@ static int syn_add_cluster(char_u *name)
     return 0;
   }
 
-  /*
-   * Make room for at least one other cluster entry.
-   */
-  ga_grow(&curwin->w_s->b_syn_clusters, 1);
-
-  memset(&(SYN_CLSTR(curwin->w_s)[len]), 0, sizeof(syn_cluster_T));
-  SYN_CLSTR(curwin->w_s)[len].scl_name = name;
-  SYN_CLSTR(curwin->w_s)[len].scl_name_u = vim_strsave_up(name);
-  SYN_CLSTR(curwin->w_s)[len].scl_list = NULL;
-  ++curwin->w_s->b_syn_clusters.ga_len;
+  syn_cluster_T *scp = GA_APPEND_VIA_PTR(syn_cluster_T,
+                                         &curwin->w_s->b_syn_clusters);
+  memset(scp, 0, sizeof(*scp));
+  scp->scl_name = name;
+  scp->scl_name_u = vim_strsave_up(name);
+  scp->scl_list = NULL;
 
   if (STRICMP(name, "Spell") == 0)
     curwin->w_s->b_spell_cluster_id = len + SYNID_CLUSTER;
@@ -5701,8 +5694,7 @@ static void syntime_report(void)
   for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; ++idx) {
     spp = &(SYN_ITEMS(curwin->w_s)[idx]);
     if (spp->sp_time.count > 0) {
-      ga_grow(&ga, 1);
-      p = ((time_entry_T *)ga.ga_data) + ga.ga_len;
+      p = GA_APPEND_VIA_PTR(time_entry_T, &ga);
       p->total = spp->sp_time.total;
       profile_add(&total_total, &spp->sp_time.total);
       p->count = spp->sp_time.count;
@@ -5713,7 +5705,6 @@ static void syntime_report(void)
       p->average = tm;
       p->id = spp->sp_syn.id;
       p->pattern = spp->sp_pattern;
-      ++ga.ga_len;
     }
   }
 
@@ -6810,10 +6801,8 @@ static int get_attr_entry(garray_T *table, attrentry_T *aep)
   /*
    * This is a new combination of colors and font, add an entry.
    */
-  ga_grow(table, 1);
-
-  taep = &(((attrentry_T *)table->ga_data)[table->ga_len]);
-  memset(taep, 0, sizeof(attrentry_T));
+  taep = GA_APPEND_VIA_PTR(attrentry_T, table);
+  memset(taep, 0, sizeof(*taep));
   taep->ae_attr = aep->ae_attr;
   if (table == &term_attr_table) {
     if (aep->ae_u.term.start == NULL)
@@ -6828,7 +6817,7 @@ static int get_attr_entry(garray_T *table, attrentry_T *aep)
     taep->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color;
     taep->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color;
   }
-  ++table->ga_len;
+
   return table->ga_len - 1 + ATTR_OFF;
 }
 
@@ -7319,15 +7308,11 @@ static int syn_add_group(char_u *name)
     return 0;
   }
 
-  /*
-   * Make room for at least one other syntax_highlight entry.
-   */
-  ga_grow(&highlight_ga, 1);
-
-  memset(&(HL_TABLE()[highlight_ga.ga_len]), 0, sizeof(struct hl_group));
-  HL_TABLE()[highlight_ga.ga_len].sg_name = name;
-  HL_TABLE()[highlight_ga.ga_len].sg_name_u = vim_strsave_up(name);
-  ++highlight_ga.ga_len;
+  // Append another syntax_highlight entry.
+  struct hl_group* hlgp = GA_APPEND_VIA_PTR(struct hl_group, &highlight_ga);
+  memset(hlgp, 0, sizeof(*hlgp));
+  hlgp->sg_name = name;
+  hlgp->sg_name_u = vim_strsave_up(name);
 
   return highlight_ga.ga_len;               /* ID is index plus one */
 }