eval: Do not allocate b:changedtick dictionary item

4 files changed, 21 insertions, 19 deletions

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 64e73b65d5..9e0dc75222 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -1443,17 +1443,18 @@ static int top_file_num = 1;            ///< highest file number
 static inline void buf_init_changedtick(buf_T *const buf)
   FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
 {
-  dictitem_T *const changedtick_di = dictitem_alloc((char_u *)"changedtick");
-  // For some reason `islocked('b:changedtick')` should return 1. It does not
-  // do so for other read-only variables which are normally VAR_FIXED.
-  changedtick_di->di_flags |= DI_FLAGS_RO|DI_FLAGS_FIX;
-  changedtick_di->di_tv = (typval_T) {
-    .v_type = VAR_NUMBER,
-    .v_lock = VAR_FIXED,
-    .vval.v_number = buf->b_changedtick,
+  buf->changedtick_di = (dictitem16_T) {
+    .di_flags = DI_FLAGS_RO|DI_FLAGS_FIX,  // Must not include DI_FLAGS_ALLOC.
+    .di_tv = (typval_T) {
+      .v_type = VAR_NUMBER,
+      .v_lock = VAR_FIXED,
+      .vval.v_number = buf->b_changedtick,
+    },
   };
-  dict_add(buf->b_vars, changedtick_di);
-  buf->changedtick_val = &changedtick_di->di_tv.vval.v_number;
+  STATIC_ASSERT(sizeof("changedtick") <= sizeof(buf->changedtick_di.di_key),
+                "buf->changedtick_di cannot hold large enough keys");
+  memcpy(buf->changedtick_di.di_key, "changedtick", sizeof("changedtick"));
+  dict_add(buf->b_vars, (dictitem_T *)&buf->changedtick_di);
 }
 
 /// Add a file name to the buffer list.
diff --git a/src/nvim/buffer.h b/src/nvim/buffer.h
index 2633c1f9d8..9b57ecf7ff 100644
--- a/src/nvim/buffer.h
+++ b/src/nvim/buffer.h
@@ -96,10 +96,11 @@ static inline void buf_set_changedtick(buf_T *const buf, const int changedtick)
   assert(changedtick_di != NULL);
   assert(changedtick_di->di_tv.v_type == VAR_NUMBER);
   assert(changedtick_di->di_tv.v_lock == VAR_FIXED);
-  assert(&changedtick_di->di_tv.vval.v_number == buf->changedtick_val);
-  assert(*buf->changedtick_val == (varnumber_T)buf->b_changedtick);
+  assert(changedtick_di->di_flags == (DI_FLAGS_RO|DI_FLAGS_FIX));
+  assert(changedtick_di == (dictitem_T *)&buf->changedtick_di);
+  assert(&buf->b_changedtick == &buf->changedtick_di.di_tv.vval.v_number);
 #endif
-  *buf->changedtick_val = buf->b_changedtick = changedtick;
+  buf->b_changedtick = changedtick;
 }
 
 #define WITH_BUFFER(b, code) \
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 514ef5a437..31e95c9fa6 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -499,8 +499,9 @@ struct file_buffer {
 
   int b_changed;                // 'modified': Set to true if something in the
                                 // file has been changed and not written out.
-  int b_changedtick;            // incremented for each change, also for undo
-  varnumber_T *changedtick_val;  // Pointer to the changedtick storage inside b:
+/// Change identifier incremented for each change, including undo
+#define b_changedtick changedtick_di.di_tv.vval.v_number
+  dictitem16_T changedtick_di;  // b:changedtick dictionary item.
 
   bool b_saving;                /* Set to true if we are in the middle of
                                    saving the buffer. */
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 4881b031e3..cc31bce877 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -550,7 +550,7 @@ void eval_init(void)
     type_list->lv_lock = VAR_FIXED;
     type_list->lv_refcount = 1;
     dictitem_T *const di = dictitem_alloc((char_u *) msgpack_type_names[i]);
-    di->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
+    di->di_flags |= DI_FLAGS_RO|DI_FLAGS_FIX;
     di->di_tv = (typval_T) {
       .v_type = VAR_LIST,
       .vval = { .v_list = type_list, },
@@ -6446,9 +6446,8 @@ static void dict_free_contents(dict_T *d) {
        * something recursive causing trouble. */
       di = HI2DI(hi);
       hash_remove(&d->dv_hashtab, hi);
-      clear_tv(&di->di_tv);
-      xfree(di);
-      --todo;
+      dictitem_free(di);
+      todo--;
     }
   }