*: Rename main loop variable from loop to main_loop

Current name is inappropriate for the following reasons:

1. It is often masked by local `loop` variables.
2. It cannot be searched for. There are many `loop` variables where `loop` is
   some local variable. There are many cases when “loop” word is used in
   a comment.
3. It is in any case bad idea to use a generic name as a name of the global
   variable. Best if global has module prefix: this is why it is in `main.h`:
   `main_loop` both stands for “a main loop” and “a loop defined in `main.*`”.

Since I have no idea how to list every occurrence of this variable method used
to rename it is “remove it from globals.h, try to compile, fix errors”. Thus if
some occurrence was hidden under false `#if` branch it was not replaced.

19 files changed, 66 insertions, 51 deletions

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index e131da8fe0..44aaedb9b4 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -961,7 +961,7 @@ static int insert_handle_key(InsertState *s)
     break;
 
   case K_EVENT:       // some event
-    queue_process_events(loop.events);
+    queue_process_events(main_loop.events);
     break;
 
   case K_FOCUSGAINED:  // Neovim has been given focus
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 420a712e3e..e6f40a0bb8 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -67,6 +67,7 @@
 #include "nvim/syntax.h"
 #include "nvim/tag.h"
 #include "nvim/ui.h"
+#include "nvim/main.h"
 #include "nvim/mouse.h"
 #include "nvim/terminal.h"
 #include "nvim/undo.h"
@@ -11812,7 +11813,7 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv)
   list_T *rv = list_alloc();
 
   ui_busy_start();
-  Queue *waiting_jobs = queue_new_parent(loop_on_put, &loop);
+  Queue *waiting_jobs = queue_new_parent(loop_on_put, &main_loop);
   // For each item in the input list append an integer to the output list. -3
   // is used to represent an invalid job id, -2 is for a interrupted job and
   // -1 for jobs that were skipped or timed out.
@@ -11890,7 +11891,7 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv)
     }
     // restore the parent queue for the job
     queue_process_events(data->events);
-    queue_replace_parent(data->events, loop.events);
+    queue_replace_parent(data->events, main_loop.events);
   }
 
   queue_free(waiting_jobs);
@@ -16534,8 +16535,8 @@ static void f_timer_start(typval_T *argvars, typval_T *rettv)
   timer->timer_id = last_timer_id++;
   timer->callback = func;
 
-  time_watcher_init(&loop, &timer->tw, timer);
-  timer->tw.events = queue_new_child(loop.events);
+  time_watcher_init(&main_loop, &timer->tw, timer);
+  timer->tw.events = queue_new_child(main_loop.events);
   // if main loop is blocked, don't queue up multiple events
   timer->tw.blockable = true;
   time_watcher_start(&timer->tw, timer_due_cb, timeout,
@@ -21712,11 +21713,11 @@ static inline TerminalJobData *common_job_init(char **argv,
   data->on_stderr = on_stderr;
   data->on_exit = on_exit;
   data->self = self;
-  data->events = queue_new_child(loop.events);
+  data->events = queue_new_child(main_loop.events);
   if (pty) {
-    data->proc.pty = pty_process_init(&loop, data);
+    data->proc.pty = pty_process_init(&main_loop, data);
   } else {
-    data->proc.uv = libuv_process_init(&loop, data);
+    data->proc.uv = libuv_process_init(&main_loop, data);
   }
   Process *proc = (Process *)&data->proc;
   proc->argv = argv;
@@ -21814,7 +21815,7 @@ static inline void free_term_job_data(TerminalJobData *data)
 {
   // data->queue may still be used after this function returns(process_wait), so
   // only free in the next event loop iteration
-  queue_put(loop.fast_events, free_term_job_data_event, 1, data);
+  queue_put(main_loop.fast_events, free_term_job_data_event, 1, data);
 }
 
 // vimscript job callbacks must be executed on Nvim main loop
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 59962c153b..dd096af6b3 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -6992,7 +6992,7 @@ void do_sleep(long msec)
   ui_flush();  // flush before waiting
   for (long left = msec; !got_int && left > 0; left -= 1000L) {
     int next = left > 1000l ? 1000 : (int)left;
-    LOOP_PROCESS_EVENTS_UNTIL(&loop, loop.events, (int)next, got_int);
+    LOOP_PROCESS_EVENTS_UNTIL(&main_loop, main_loop.events, (int)next, got_int);
     os_breakcheck();
   }
 }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index db21fddedb..65144dace8 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -358,7 +358,7 @@ static int command_line_execute(VimState *state, int key)
   s->c = key;
 
   if (s->c == K_EVENT) {
-    queue_process_events(loop.events);
+    queue_process_events(main_loop.events);
     redrawcmdline();
     return 1;
   }
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index dafb75ca87..f618e5ffc4 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -1243,7 +1243,6 @@ EXTERN char *ignoredp;
 
 // If a msgpack-rpc channel should be started over stdin/stdout
 EXTERN bool embedded_mode INIT(= false);
-EXTERN Loop loop;
 
 /// Used to track the status of external functions.
 /// Currently only used for iconv().
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 71a972e8f6..2b14e6a777 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -120,6 +120,8 @@ typedef struct {
 # include "main.c.generated.h"
 #endif
 
+Loop main_loop;
+
 static char *argv0;
 
 // Error messages
@@ -133,7 +135,7 @@ static const char *err_extra_cmd =
 
 void event_init(void)
 {
-  loop_init(&loop, NULL);
+  loop_init(&main_loop, NULL);
   // early msgpack-rpc initialization
   msgpack_rpc_init_method_table();
   msgpack_rpc_helpers_init();
@@ -151,19 +153,19 @@ void event_init(void)
 
 void event_teardown(void)
 {
-  if (!loop.events) {
+  if (!main_loop.events) {
     return;
   }
 
-  queue_process_events(loop.events);
+  queue_process_events(main_loop.events);
   input_stop();
   channel_teardown();
-  process_teardown(&loop);
+  process_teardown(&main_loop);
   server_teardown();
   signal_teardown();
   terminal_teardown();
 
-  loop_close(&loop);
+  loop_close(&main_loop);
 }
 
 /// Performs early initialization.
diff --git a/src/nvim/main.h b/src/nvim/main.h
index 084e247b7e..86d25fe657 100644
--- a/src/nvim/main.h
+++ b/src/nvim/main.h
@@ -2,6 +2,9 @@
 #define NVIM_MAIN_H
 
 #include "nvim/normal.h"
+#include "nvim/event/loop.h"
+
+extern Loop main_loop;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "main.h.generated.h"
diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
index 3a6d7c1434..2e4bd396b7 100644
--- a/src/nvim/msgpack_rpc/channel.c
+++ b/src/nvim/msgpack_rpc/channel.c
@@ -16,6 +16,7 @@
 #include "nvim/event/socket.h"
 #include "nvim/msgpack_rpc/helpers.h"
 #include "nvim/vim.h"
+#include "nvim/main.h"
 #include "nvim/ascii.h"
 #include "nvim/memory.h"
 #include "nvim/os_unix.h"
@@ -119,7 +120,7 @@ void channel_teardown(void)
 uint64_t channel_from_process(char **argv)
 {
   Channel *channel = register_channel(kChannelTypeProc);
-  channel->data.process.uvproc = libuv_process_init(&loop, channel);
+  channel->data.process.uvproc = libuv_process_init(&main_loop, channel);
   Process *proc = &channel->data.process.uvproc.process;
   proc->argv = argv;
   proc->in = &channel->data.process.in;
@@ -127,7 +128,7 @@ uint64_t channel_from_process(char **argv)
   proc->err = &channel->data.process.err;
   proc->cb = process_exit;
   if (!process_spawn(proc)) {
-    loop_poll_events(&loop, 0);
+    loop_poll_events(&main_loop, 0);
     decref(channel);
     return 0;
   }
@@ -220,7 +221,7 @@ Object channel_send_call(uint64_t id,
   ChannelCallFrame frame = {request_id, false, false, NIL};
   kv_push(ChannelCallFrame *, channel->call_stack, &frame);
   channel->pending_requests++;
-  LOOP_PROCESS_EVENTS_UNTIL(&loop, channel->events, -1, frame.returned);
+  LOOP_PROCESS_EVENTS_UNTIL(&main_loop, channel->events, -1, frame.returned);
   (void)kv_pop(channel->call_stack);
   channel->pending_requests--;
 
@@ -316,11 +317,11 @@ void channel_from_stdio(void)
   Channel *channel = register_channel(kChannelTypeStdio);
   incref(channel);  // stdio channels are only closed on exit
   // read stream
-  rstream_init_fd(&loop, &channel->data.std.in, 0, CHANNEL_BUFFER_SIZE,
-      channel);
+  rstream_init_fd(&main_loop, &channel->data.std.in, 0, CHANNEL_BUFFER_SIZE,
+                  channel);
   rstream_start(&channel->data.std.in, parse_msgpack);
   // write stream
-  wstream_init_fd(&loop, &channel->data.std.out, 1, 0, NULL);
+  wstream_init_fd(&main_loop, &channel->data.std.out, 1, 0, NULL);
 }
 
 static void forward_stderr(Stream *stream, RBuffer *rbuf, size_t count,
@@ -647,7 +648,7 @@ static void close_channel(Channel *channel)
     case kChannelTypeStdio:
       stream_close(&channel->data.std.in, NULL);
       stream_close(&channel->data.std.out, NULL);
-      queue_put(loop.fast_events, exit_event, 1, channel);
+      queue_put(main_loop.fast_events, exit_event, 1, channel);
       return;
     default:
       abort();
@@ -692,7 +693,7 @@ static void close_cb(Stream *stream, void *data)
 static Channel *register_channel(ChannelType type)
 {
   Channel *rv = xmalloc(sizeof(Channel));
-  rv->events = queue_new_child(loop.events);
+  rv->events = queue_new_child(main_loop.events);
   rv->type = type;
   rv->refcount = 1;
   rv->closed = false;
diff --git a/src/nvim/msgpack_rpc/server.c b/src/nvim/msgpack_rpc/server.c
index 6cc56ba3dd..abbd3e8aff 100644
--- a/src/nvim/msgpack_rpc/server.c
+++ b/src/nvim/msgpack_rpc/server.c
@@ -12,6 +12,7 @@
 #include "nvim/eval.h"
 #include "nvim/garray.h"
 #include "nvim/vim.h"
+#include "nvim/main.h"
 #include "nvim/memory.h"
 #include "nvim/log.h"
 #include "nvim/fileio.h"
@@ -108,7 +109,7 @@ int server_start(const char *endpoint)
   }
 
   SocketWatcher *watcher = xmalloc(sizeof(SocketWatcher));
-  socket_watcher_init(&loop, watcher, endpoint, NULL);
+  socket_watcher_init(&main_loop, watcher, endpoint, NULL);
 
   // Check if a watcher for the endpoint already exists
   for (int i = 0; i < watchers.ga_len; i++) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 382c4943ff..cc604352e1 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -7879,7 +7879,7 @@ static void nv_event(cmdarg_T *cap)
   // not safe to perform garbage collection because there could be unreferenced
   // lists or dicts being used.
   may_garbage_collect = false;
-  queue_process_events(loop.events);
+  queue_process_events(main_loop.events);
   cap->retval |= CA_COMMAND_BUSY;       // don't call edit() now
 }
 
diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index 7687b14f02..0c46dc96ee 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -60,7 +60,7 @@ void input_start(int fd)
   }
 
   global_fd = fd;
-  rstream_init_fd(&loop, &read_stream, fd, READ_BUFFER_SIZE, NULL);
+  rstream_init_fd(&main_loop, &read_stream, fd, READ_BUFFER_SIZE, NULL);
   rstream_start(&read_stream, read_cb);
 }
 
@@ -87,8 +87,8 @@ static void create_cursorhold_event(void)
   // have been called(inbuf_poll would return kInputAvail)
   // TODO(tarruda): Cursorhold should be implemented as a timer set during the
   // `state_check` callback for the states where it can be triggered.
-  assert(!events_enabled || queue_empty(loop.events));
-  queue_put(loop.events, cursorhold_event, 0);
+  assert(!events_enabled || queue_empty(main_loop.events));
+  queue_put(main_loop.events, cursorhold_event, 0);
 }
 
 // Low level input function
@@ -147,7 +147,7 @@ bool os_char_avail(void)
 void os_breakcheck(void)
 {
   if (!got_int) {
-    loop_poll_events(&loop, 0);
+    loop_poll_events(&main_loop, 0);
   }
 }
 
@@ -322,7 +322,7 @@ static bool input_poll(int ms)
     prof_inchar_enter();
   }
 
-  LOOP_PROCESS_EVENTS_UNTIL(&loop, NULL, ms, input_ready() || input_eof);
+  LOOP_PROCESS_EVENTS_UNTIL(&main_loop, NULL, ms, input_ready() || input_eof);
 
   if (do_profiling == PROF_YES && ms) {
     prof_inchar_exit();
@@ -419,5 +419,5 @@ static void read_error_exit(void)
 
 static bool pending_events(void)
 {
-  return events_enabled && !queue_empty(loop.events);
+  return events_enabled && !queue_empty(main_loop.events);
 }
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index f5a1637c94..988620b145 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -14,6 +14,7 @@
 #include "nvim/os/shell.h"
 #include "nvim/os/signal.h"
 #include "nvim/types.h"
+#include "nvim/main.h"
 #include "nvim/vim.h"
 #include "nvim/message.h"
 #include "nvim/memory.h"
@@ -205,16 +206,16 @@ static int do_os_system(char **argv,
   xstrlcpy(prog, argv[0], MAXPATHL);
 
   Stream in, out, err;
-  LibuvProcess uvproc = libuv_process_init(&loop, &buf);
+  LibuvProcess uvproc = libuv_process_init(&main_loop, &buf);
   Process *proc = &uvproc.process;
-  Queue *events = queue_new_child(loop.events);
+  Queue *events = queue_new_child(main_loop.events);
   proc->events = events;
   proc->argv = argv;
   proc->in = input != NULL ? &in : NULL;
   proc->out = &out;
   proc->err = &err;
   if (!process_spawn(proc)) {
-    loop_poll_events(&loop, 0);
+    loop_poll_events(&main_loop, 0);
     // Failed, probably due to `sh` not being executable
     if (!silent) {
       MSG_PUTS(_("\nCannot execute "));
diff --git a/src/nvim/os/signal.c b/src/nvim/os/signal.c
index 0ff6016e32..4abc9cfc36 100644
--- a/src/nvim/os/signal.c
+++ b/src/nvim/os/signal.c
@@ -8,6 +8,7 @@
 #include "nvim/globals.h"
 #include "nvim/memline.h"
 #include "nvim/eval.h"
+#include "nvim/main.h"
 #include "nvim/memory.h"
 #include "nvim/misc1.h"
 #include "nvim/misc2.h"
@@ -28,10 +29,10 @@ static bool rejecting_deadly;
 
 void signal_init(void)
 {
-  signal_watcher_init(&loop, &spipe, NULL);
-  signal_watcher_init(&loop, &shup, NULL);
-  signal_watcher_init(&loop, &squit, NULL);
-  signal_watcher_init(&loop, &sterm, NULL);
+  signal_watcher_init(&main_loop, &spipe, NULL);
+  signal_watcher_init(&main_loop, &shup, NULL);
+  signal_watcher_init(&main_loop, &squit, NULL);
+  signal_watcher_init(&main_loop, &sterm, NULL);
 #ifdef SIGPIPE
   signal_watcher_start(&spipe, on_signal, SIGPIPE);
 #endif
@@ -41,7 +42,7 @@ void signal_init(void)
 #endif
   signal_watcher_start(&sterm, on_signal, SIGTERM);
 #ifdef SIGPWR
-  signal_watcher_init(&loop, &spwr, NULL);
+  signal_watcher_init(&main_loop, &spwr, NULL);
   signal_watcher_start(&spwr, on_signal, SIGPWR);
 #endif
 }
diff --git a/src/nvim/os/time.c b/src/nvim/os/time.c
index 188f0802c9..2205ad0958 100644
--- a/src/nvim/os/time.c
+++ b/src/nvim/os/time.c
@@ -9,6 +9,7 @@
 #include "nvim/os/time.h"
 #include "nvim/event/loop.h"
 #include "nvim/vim.h"
+#include "nvim/main.h"
 
 static uv_mutex_t delay_mutex;
 static uv_cond_t delay_cond;
@@ -43,7 +44,7 @@ void os_delay(uint64_t milliseconds, bool ignoreinput)
     if (milliseconds > INT_MAX) {
       milliseconds = INT_MAX;
     }
-    LOOP_PROCESS_EVENTS_UNTIL(&loop, NULL, (int)milliseconds, got_int);
+    LOOP_PROCESS_EVENTS_UNTIL(&main_loop, NULL, (int)milliseconds, got_int);
   } else {
     os_microdelay(milliseconds * 1000);
   }
diff --git a/src/nvim/state.c b/src/nvim/state.c
index b2f3f0bebe..30133e2201 100644
--- a/src/nvim/state.c
+++ b/src/nvim/state.c
@@ -4,6 +4,7 @@
 
 #include "nvim/state.h"
 #include "nvim/vim.h"
+#include "nvim/main.h"
 #include "nvim/getchar.h"
 #include "nvim/ui.h"
 #include "nvim/os/input.h"
@@ -32,7 +33,7 @@ getkey:
       // processing. Characters can come from mappings, scripts and other
       // sources, so this scenario is very common.
       key = safe_vgetc();
-    } else if (!queue_empty(loop.events)) {
+    } else if (!queue_empty(main_loop.events)) {
       // Event was made available after the last queue_process_events call
       key = K_EVENT;
     } else {
@@ -45,7 +46,7 @@ getkey:
       // directly.
       (void)os_inchar(NULL, 0, -1, 0);
       input_disable_events();
-      key = !queue_empty(loop.events) ? K_EVENT : safe_vgetc();
+      key = !queue_empty(main_loop.events) ? K_EVENT : safe_vgetc();
     }
 
     if (key == K_EVENT) {
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 104cc47cda..df5e03880a 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -63,6 +63,7 @@
 #include "nvim/map.h"
 #include "nvim/misc1.h"
 #include "nvim/move.h"
+#include "nvim/main.h"
 #include "nvim/state.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_cmds.h"
@@ -163,9 +164,9 @@ static VTermColor default_vt_bg_rgb;
 void terminal_init(void)
 {
   invalidated_terminals = pmap_new(ptr_t)();
-  time_watcher_init(&loop, &refresh_timer, NULL);
+  time_watcher_init(&main_loop, &refresh_timer, NULL);
   // refresh_timer_cb will redraw the screen which can call vimscript
-  refresh_timer.events = queue_new_child(loop.events);
+  refresh_timer.events = queue_new_child(main_loop.events);
 
   // initialize a rgb->color index map for cterm attributes(VTermScreenCell
   // only has RGB information and we need color indexes for terminal UIs)
@@ -452,7 +453,7 @@ static int terminal_execute(VimState *state, int key)
     case K_EVENT:
       // We cannot let an event free the terminal yet. It is still needed.
       s->term->refcount++;
-      queue_process_events(loop.events);
+      queue_process_events(main_loop.events);
       s->term->refcount--;
       if (s->term->buf_handle == 0) {
         s->close = true;
diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index 99eb230a88..f374c6dc7a 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -4,6 +4,7 @@
 #include "nvim/api/vim.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/ascii.h"
+#include "nvim/main.h"
 #include "nvim/misc2.h"
 #include "nvim/os/os.h"
 #include "nvim/os/input.h"
@@ -92,7 +93,7 @@ static void flush_input(TermInput *input, bool wait_until_empty)
   size_t drain_boundary = wait_until_empty ? 0 : 0xff;
   do {
     uv_mutex_lock(&input->key_buffer_mutex);
-    loop_schedule(&loop, event_create(1, wait_input_enqueue, 1, input));
+    loop_schedule(&main_loop, event_create(1, wait_input_enqueue, 1, input));
     input->waiting = true;
     while (input->waiting) {
       uv_cond_wait(&input->key_buffer_cond, &input->key_buffer_mutex);
@@ -336,7 +337,7 @@ static void read_cb(Stream *stream, RBuffer *buf, size_t c, void *data,
       stream_close(&input->read_stream, NULL);
       queue_put(input->loop->fast_events, restart_reading, 1, input);
     } else {
-      loop_schedule(&loop, event_create(1, input_done_event, 0));
+      loop_schedule(&main_loop, event_create(1, input_done_event, 0));
     }
     return;
   }
diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c
index 62bc81ba64..4732b816c5 100644
--- a/src/nvim/tui/tui.c
+++ b/src/nvim/tui/tui.c
@@ -11,6 +11,7 @@
 #include "nvim/vim.h"
 #include "nvim/ui.h"
 #include "nvim/map.h"
+#include "nvim/main.h"
 #include "nvim/memory.h"
 #include "nvim/api/vim.h"
 #include "nvim/api/private/helpers.h"
@@ -261,7 +262,7 @@ static void sigwinch_cb(SignalWatcher *watcher, int signum, void *data)
   UI *ui = data;
   update_size(ui);
   // run refresh_event in nvim main loop
-  loop_schedule(&loop, event_create(1, refresh_event, 0));
+  loop_schedule(&main_loop, event_create(1, refresh_event, 0));
 }
 
 static bool attrs_differ(HlAttrs a1, HlAttrs a2)
diff --git a/src/nvim/ui_bridge.c b/src/nvim/ui_bridge.c
index d17fa4a782..41d35684b1 100644
--- a/src/nvim/ui_bridge.c
+++ b/src/nvim/ui_bridge.c
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <limits.h>
 
+#include "nvim/main.h"
 #include "nvim/vim.h"
 #include "nvim/ui.h"
 #include "nvim/memory.h"
@@ -100,7 +101,7 @@ static void ui_bridge_stop(UI *b)
     if (stopped) {
       break;
     }
-    loop_poll_events(&loop, 10);
+    loop_poll_events(&main_loop, 10);
   }
   uv_thread_join(&bridge->ui_thread);
   uv_mutex_destroy(&bridge->mutex);