Fix 'SyntaxError: invalid syntax' on Python 3.7

'async' is keyword in Python 3.7

https://www.python.org/dev/peps/pep-0492/#deprecation-plans

Author: lambdalisue

neovim/api/buffer.py

@@ -98,17 +98,17 @@ def range(self, start, end):
         return Range(self, start, end)
 
     def add_highlight(self, hl_group, line, col_start=0,
-                      col_end=-1, src_id=-1, async=None):
+                      col_end=-1, src_id=-1, async_=None):
         """Add a highlight to the buffer."""
-        if async is None:
-            async = (src_id != 0)
+        if async_ is None:
+            async_ = (src_id != 0)
         return self.request('nvim_buf_add_highlight', src_id, hl_group,
-                            line, col_start, col_end, async=async)
+                            line, col_start, col_end, async_=async_)
 
-    def clear_highlight(self, src_id, line_start=0, line_end=-1, async=True):
+    def clear_highlight(self, src_id, line_start=0, line_end=-1, async_=True):
         """Clear highlights from the buffer."""
         self.request('nvim_buf_clear_highlight', src_id,
-                     line_start, line_end, async=async)
+                     line_start, line_end, async_=async_)
 
     @property
     def name(self):

neovim/api/nvim.py

@@ -122,16 +122,16 @@ def request(self, name, *args, **kwargs):
         functions have python wrapper functions. The `api` object can
         be also be used to call API functions as methods:
 
-            vim.api.err_write('ERROR\n', async=True)
+            vim.api.err_write('ERROR\n', async_=True)
             vim.current.buffer.api.get_mark('.')
 
         is equivalent to
 
-            vim.request('nvim_err_write', 'ERROR\n', async=True)
+            vim.request('nvim_err_write', 'ERROR\n', async_=True)
             vim.request('nvim_buf_get_mark', vim.current.buffer, '.')
 
 
-        Normally a blocking request will be sent.  If the `async` flag is
+        Normally a blocking request will be sent.  If the `async_` flag is
         present and True, a asynchronous notification is sent instead. This
         will never block, and the return value or error is ignored.
         """

neovim/msgpack_rpc/session.py

@@ -72,12 +72,12 @@ def request(self, method, *args, **kwargs):
         - Run the loop until the response is available
         - Put requests/notifications received while waiting into a queue
 
-        If the `async` flag is present and True, a asynchronous notification is
-        sent instead. This will never block, and the return value or error is
-        ignored.
+        If the `async_` flag is present and True, a asynchronous notification
+        is sent instead. This will never block, and the return value or error
+        is ignored.
         """
-        async = kwargs.pop('async', False)
-        if async:
+        async_ = kwargs.pop('async_', False)
+        if async_:
             self._async_session.notify(method, args)
             return
 

neovim/plugin/host.py

@@ -46,7 +46,7 @@ def __init__(self, nvim):
         self._decode_default = IS_PYTHON3
 
     def _on_async_err(self, msg):
-        self.nvim.err_write(msg, async=True)
+        self.nvim.err_write(msg, async_=True)
 
     def start(self, plugins):
         """Start listening for msgpack-rpc requests and notifications."""

test/test_client_rpc.py

@@ -44,7 +44,7 @@ def request_cb(name, args):
         vim.stop_loop()
 
     # this would have dead-locked if not async
-    vim.funcs.rpcrequest(vim.channel_id, "test-event", async=True)
+    vim.funcs.rpcrequest(vim.channel_id, "test-event", async_=True)
     vim.run_loop(request_cb, None, None)
     eq(vim.vars['result'], 17)
 

test/test_events.py

@@ -19,15 +19,15 @@ def test_receiving_events():
 @with_setup(setup=cleanup)
 def test_sending_notify():
     # notify after notify
-    vim.command("let g:test = 3", async=True)
+    vim.command("let g:test = 3", async_=True)
     cmd = 'call rpcnotify(%d, "test-event", g:test)' % vim.channel_id
-    vim.command(cmd, async=True)
+    vim.command(cmd, async_=True)
     event = vim.next_message()
     eq(event[1], 'test-event')
     eq(event[2], [3])
 
     # request after notify
-    vim.command("let g:data = 'xyz'", async=True)
+    vim.command("let g:data = 'xyz'", async_=True)
     eq(vim.eval('g:data'), 'xyz')