1 files changed, 39 insertions, 39 deletions

diff --git a/src/nvim/event/multiqueue.c b/src/nvim/event/multiqueue.c
index 8f8a36eff9..0096d0e11e 100644
--- a/src/nvim/event/multiqueue.c
+++ b/src/nvim/event/multiqueue.c
@@ -112,13 +112,13 @@ static MultiQueue *multiqueue_new(MultiQueue *parent, PutCallback put_cb, void *
   return rv;
 }
 
-void multiqueue_free(MultiQueue *this)
+void multiqueue_free(MultiQueue *self)
 {
-  assert(this);
+  assert(self);
   QUEUE *q;
-  QUEUE_FOREACH(q, &this->headtail, {
+  QUEUE_FOREACH(q, &self->headtail, {
     MultiQueueItem *item = multiqueue_node_data(q);
-    if (this->parent) {
+    if (self->parent) {
       QUEUE_REMOVE(&item->data.item.parent_item->node);
       xfree(item->data.item.parent_item);
     }
@@ -126,29 +126,29 @@ void multiqueue_free(MultiQueue *this)
     xfree(item);
   })
 
-  xfree(this);
+  xfree(self);
 }
 
 /// Removes the next item and returns its Event.
-Event multiqueue_get(MultiQueue *this)
+Event multiqueue_get(MultiQueue *self)
 {
-  return multiqueue_empty(this) ? NILEVENT : multiqueue_remove(this);
+  return multiqueue_empty(self) ? NILEVENT : multiqueue_remove(self);
 }
 
-void multiqueue_put_event(MultiQueue *this, Event event)
+void multiqueue_put_event(MultiQueue *self, Event event)
 {
-  assert(this);
-  multiqueue_push(this, event);
-  if (this->parent && this->parent->put_cb) {
-    this->parent->put_cb(this->parent, this->parent->data);
+  assert(self);
+  multiqueue_push(self, event);
+  if (self->parent && self->parent->put_cb) {
+    self->parent->put_cb(self->parent, self->parent->data);
   }
 }
 
-void multiqueue_process_events(MultiQueue *this)
+void multiqueue_process_events(MultiQueue *self)
 {
-  assert(this);
-  while (!multiqueue_empty(this)) {
-    Event event = multiqueue_remove(this);
+  assert(self);
+  while (!multiqueue_empty(self)) {
+    Event event = multiqueue_remove(self);
     if (event.handler) {
       event.handler(event.argv);
     }
@@ -156,30 +156,30 @@ void multiqueue_process_events(MultiQueue *this)
 }
 
 /// Removes all events without processing them.
-void multiqueue_purge_events(MultiQueue *this)
+void multiqueue_purge_events(MultiQueue *self)
 {
-  assert(this);
-  while (!multiqueue_empty(this)) {
-    (void)multiqueue_remove(this);
+  assert(self);
+  while (!multiqueue_empty(self)) {
+    (void)multiqueue_remove(self);
   }
 }
 
-bool multiqueue_empty(MultiQueue *this)
+bool multiqueue_empty(MultiQueue *self)
 {
-  assert(this);
-  return QUEUE_EMPTY(&this->headtail);
+  assert(self);
+  return QUEUE_EMPTY(&self->headtail);
 }
 
-void multiqueue_replace_parent(MultiQueue *this, MultiQueue *new_parent)
+void multiqueue_replace_parent(MultiQueue *self, MultiQueue *new_parent)
 {
-  assert(multiqueue_empty(this));
-  this->parent = new_parent;
+  assert(multiqueue_empty(self));
+  self->parent = new_parent;
 }
 
 /// Gets the count of all events currently in the queue.
-size_t multiqueue_size(MultiQueue *this)
+size_t multiqueue_size(MultiQueue *self)
 {
-  return this->size;
+  return self->size;
 }
 
 /// Gets an Event from an item.
@@ -213,35 +213,35 @@ static Event multiqueueitem_get_event(MultiQueueItem *item, bool remove)
   return ev;
 }
 
-static Event multiqueue_remove(MultiQueue *this)
+static Event multiqueue_remove(MultiQueue *self)
 {
-  assert(!multiqueue_empty(this));
-  QUEUE *h = QUEUE_HEAD(&this->headtail);
+  assert(!multiqueue_empty(self));
+  QUEUE *h = QUEUE_HEAD(&self->headtail);
   QUEUE_REMOVE(h);
   MultiQueueItem *item = multiqueue_node_data(h);
-  assert(!item->link || !this->parent);  // Only a parent queue has link-nodes
+  assert(!item->link || !self->parent);  // Only a parent queue has link-nodes
   Event ev = multiqueueitem_get_event(item, true);
-  this->size--;
+  self->size--;
   xfree(item);
   return ev;
 }
 
-static void multiqueue_push(MultiQueue *this, Event event)
+static void multiqueue_push(MultiQueue *self, Event event)
 {
   MultiQueueItem *item = xmalloc(sizeof(MultiQueueItem));
   item->link = false;
   item->data.item.event = event;
   item->data.item.parent_item = NULL;
-  QUEUE_INSERT_TAIL(&this->headtail, &item->node);
-  if (this->parent) {
+  QUEUE_INSERT_TAIL(&self->headtail, &item->node);
+  if (self->parent) {
     // push link node to the parent queue
     item->data.item.parent_item = xmalloc(sizeof(MultiQueueItem));
     item->data.item.parent_item->link = true;
-    item->data.item.parent_item->data.queue = this;
-    QUEUE_INSERT_TAIL(&this->parent->headtail,
+    item->data.item.parent_item->data.queue = self;
+    QUEUE_INSERT_TAIL(&self->parent->headtail,
                       &item->data.item.parent_item->node);
   }
-  this->size++;
+  self->size++;
 }
 
 static MultiQueueItem *multiqueue_node_data(QUEUE *q)