1 files changed, 110 insertions, 20 deletions

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 35ca236831..7187386ec7 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -12103,22 +12103,7 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     tv_dict_alloc_ret(rettv);
     if (rhs != NULL) {
       // Return a dictionary.
-      char_u *lhs = str2special_save(mp->m_keys, true);
-      char *const mapmode = map_mode_to_chars(mp->m_mode);
-      dict_T *dict = rettv->vval.v_dict;
-
-      tv_dict_add_str(dict, S_LEN("lhs"), (const char *)lhs);
-      tv_dict_add_str(dict, S_LEN("rhs"), (const char *)mp->m_orig_str);
-      tv_dict_add_nr(dict, S_LEN("noremap"), mp->m_noremap ? 1 : 0);
-      tv_dict_add_nr(dict, S_LEN("expr"),  mp->m_expr ? 1 : 0);
-      tv_dict_add_nr(dict, S_LEN("silent"), mp->m_silent ? 1 : 0);
-      tv_dict_add_nr(dict, S_LEN("sid"), (varnumber_T)mp->m_script_ID);
-      tv_dict_add_nr(dict, S_LEN("buffer"), (varnumber_T)buffer_local);
-      tv_dict_add_nr(dict, S_LEN("nowait"), mp->m_nowait ? 1 : 0);
-      tv_dict_add_str(dict, S_LEN("mode"), mapmode);
-
-      xfree(lhs);
-      xfree(mapmode);
+      mapblock_fill_dict(rettv->vval.v_dict, mp, buffer_local, true);
     }
   }
 }
@@ -12135,6 +12120,46 @@ static void f_luaeval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   executor_eval_lua(cstr_as_string((char *)str), &argvars[1], rettv);
 }
 
+/// Fill a dictionary with all applicable maparg() like dictionaries
+///
+/// @param  dict  The dictionary to be filled
+/// @param  mp  The maphash that contains the mapping information
+/// @param  buffer_value  The "buffer" value
+/// @param  compatible  True for compatible with old maparg() dict
+void mapblock_fill_dict(dict_T *const dict,
+                        const mapblock_T *const mp,
+                        long buffer_value,
+                        bool compatible)
+    FUNC_ATTR_NONNULL_ALL
+{
+  char_u *lhs = str2special_save(mp->m_keys, true);
+  char *const mapmode = map_mode_to_chars(mp->m_mode);
+  varnumber_T noremap_value;
+
+  if (compatible) {
+    // Keep old compatible behavior
+    // This is unable to determine whether a mapping is a <script> mapping
+    noremap_value = !!mp->m_noremap;
+  } else {
+    // Distinguish between <script> mapping
+    // If it's not a <script> mapping, check if it's a noremap
+    noremap_value = mp->m_noremap == REMAP_SCRIPT ? 2 : !!mp->m_noremap;
+  }
+
+  tv_dict_add_str(dict, S_LEN("lhs"), (const char *)lhs);
+  tv_dict_add_str(dict, S_LEN("rhs"), (const char *)mp->m_orig_str);
+  tv_dict_add_nr(dict, S_LEN("noremap"), noremap_value);
+  tv_dict_add_nr(dict, S_LEN("expr"),  mp->m_expr ? 1 : 0);
+  tv_dict_add_nr(dict, S_LEN("silent"), mp->m_silent ? 1 : 0);
+  tv_dict_add_nr(dict, S_LEN("sid"), (varnumber_T)mp->m_script_ID);
+  tv_dict_add_nr(dict, S_LEN("buffer"), (varnumber_T)buffer_value);
+  tv_dict_add_nr(dict, S_LEN("nowait"), mp->m_nowait ? 1 : 0);
+  tv_dict_add_str(dict, S_LEN("mode"), mapmode);
+
+  xfree(lhs);
+  xfree(mapmode);
+}
+
 /*
  * "map()" function
  */
@@ -14297,22 +14322,39 @@ static void f_serverstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     return;
   }
 
+  char *address;
   // If the user supplied an address, use it, otherwise use a temp.
   if (argvars[0].v_type != VAR_UNKNOWN) {
     if (argvars[0].v_type != VAR_STRING) {
       EMSG(_(e_invarg));
       return;
     } else {
-      rettv->vval.v_string = (char_u *)xstrdup(tv_get_string(argvars));
+      address = xstrdup(tv_get_string(argvars));
     }
   } else {
-    rettv->vval.v_string = (char_u *)server_address_new();
+    address = server_address_new();
   }
 
-  int result = server_start((char *) rettv->vval.v_string);
+  int result = server_start(address);
+  xfree(address);
+
   if (result != 0) {
-    EMSG2("Failed to start server: %s", uv_strerror(result));
+    EMSG2("Failed to start server: %s",
+          result > 0 ? "Unknonwn system error" : uv_strerror(result));
+    return;
   }
+
+  // Since it's possible server_start adjusted the given {address} (e.g.,
+  // "localhost:" will now have a port), return the final value to the user.
+  size_t n;
+  char **addrs = server_address_list(&n);
+  rettv->vval.v_string = (char_u *)addrs[n - 1];
+
+  n--;
+  for (size_t i = 0; i < n; i++) {
+    xfree(addrs[i]);
+  }
+  xfree(addrs);
 }
 
 /// "serverstop()" function
@@ -15027,6 +15069,54 @@ static void f_simplify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   rettv->v_type = VAR_STRING;
 }
 
+/// "sockconnect()" function
+static void f_sockconnect(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+{
+  if (argvars[0].v_type != VAR_STRING || argvars[1].v_type != VAR_STRING) {
+    EMSG(_(e_invarg));
+    return;
+  }
+  if (argvars[2].v_type != VAR_DICT && argvars[2].v_type != VAR_UNKNOWN) {
+    // Wrong argument types
+    EMSG2(_(e_invarg2), "expected dictionary");
+    return;
+  }
+
+  const char *mode = tv_get_string(&argvars[0]);
+  const char *address = tv_get_string(&argvars[1]);
+
+  bool tcp;
+  if (strcmp(mode, "tcp") == 0) {
+    tcp = true;
+  } else if (strcmp(mode, "pipe") == 0) {
+    tcp = false;
+  } else {
+    EMSG2(_(e_invarg2), "invalid mode");
+    return;
+  }
+
+  bool rpc = false;
+  if (argvars[2].v_type == VAR_DICT) {
+    dict_T *opts = argvars[2].vval.v_dict;
+    rpc = tv_dict_get_number(opts, "rpc") != 0;
+  }
+
+  if (!rpc) {
+    EMSG2(_(e_invarg2), "rpc option must be true");
+    return;
+  }
+
+  const char *error = NULL;
+  uint64_t id = channel_connect(tcp, address, 50, &error);
+
+  if (error) {
+    EMSG2(_("connection failed: %s"), error);
+  }
+
+  rettv->vval.v_number = (varnumber_T)id;
+  rettv->v_type = VAR_NUMBER;
+}
+
 /// struct used in the array that's given to qsort()
 typedef struct {
   listitem_T *item;