Merge #4411 from ZyX-I/luaviml'/lua

24 files changed, 2222 insertions, 184 deletions

diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index f69781a539..8deeff4654 100644
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -12,11 +12,10 @@ endif()
 
 set(TOUCHES_DIR ${PROJECT_BINARY_DIR}/touches)
 set(GENERATED_DIR ${PROJECT_BINARY_DIR}/src/nvim/auto)
-set(DISPATCH_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/gendispatch.lua)
-file(GLOB API_HEADERS api/*.h)
-file(GLOB MSGPACK_RPC_HEADERS msgpack_rpc/*.h)
+set(MSGPACK_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/genmsgpack.lua)
 set(API_METADATA ${PROJECT_BINARY_DIR}/api_metadata.mpack)
 set(FUNCS_DATA ${PROJECT_BINARY_DIR}/funcs_data.mpack)
+set(MSGPACK_LUA_C_BINDINGS ${GENERATED_DIR}/msgpack_lua_c_bindings.generated.c)
 set(HEADER_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/gendeclarations.lua)
 set(GENERATED_INCLUDES_DIR ${PROJECT_BINARY_DIR}/include)
 set(GENERATED_API_DISPATCH ${GENERATED_DIR}/api/private/dispatch_wrappers.generated.h)
@@ -33,8 +32,10 @@ set(EVENTS_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/gen_events.lua)
 set(OPTIONS_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/genoptions.lua)
 set(UNICODE_TABLES_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/genunicodetables.lua)
 set(UNICODE_DIR ${PROJECT_SOURCE_DIR}/unicode)
-file(GLOB UNICODE_FILES ${UNICODE_DIR}/*.txt)
 set(GENERATED_UNICODE_TABLES ${GENERATED_DIR}/unicode_tables.generated.h)
+set(VIM_MODULE_FILE ${GENERATED_DIR}/lua/vim_module.generated.h)
+set(VIM_MODULE_SOURCE ${PROJECT_SOURCE_DIR}/src/nvim/lua/vim.lua)
+set(CHAR_BLOB_GENERATOR ${PROJECT_SOURCE_DIR}/scripts/gencharblob.lua)
 set(LINT_SUPPRESS_FILE ${PROJECT_BINARY_DIR}/errors.json)
 set(LINT_SUPPRESS_URL_BASE "https://raw.githubusercontent.com/neovim/doc/gh-pages/reports/clint")
 set(LINT_SUPPRESS_URL "${LINT_SUPPRESS_URL_BASE}/errors.json")
@@ -46,6 +47,10 @@ set(LINT_SUPPRESSES_ARCHIVE ${LINT_SUPPRESSES_ROOT}/errors.tar.gz)
 set(LINT_SUPPRESSES_TOUCH_FILE "${TOUCHES_DIR}/unpacked-clint-errors-archive")
 set(LINT_SUPPRESSES_INSTALL_SCRIPT "${PROJECT_SOURCE_DIR}/cmake/InstallClintErrors.cmake")
 
+file(GLOB UNICODE_FILES ${UNICODE_DIR}/*.txt)
+file(GLOB API_HEADERS api/*.h)
+file(GLOB MSGPACK_RPC_HEADERS msgpack_rpc/*.h)
+
 include_directories(${GENERATED_DIR})
 include_directories(${CACHED_GENERATED_DIR})
 include_directories(${GENERATED_INCLUDES_DIR})
@@ -67,6 +72,7 @@ foreach(subdir
         tui
         event
         eval
+        lua
        )
   if(${subdir} MATCHES "tui" AND NOT FEAT_TUI)
     continue()
@@ -157,7 +163,7 @@ if(CLANG_ASAN_UBSAN OR CLANG_MSAN OR CLANG_TSAN)
 endif()
 
 get_directory_property(gen_includes INCLUDE_DIRECTORIES)
-foreach(gen_include ${gen_includes})
+foreach(gen_include ${gen_includes} ${LUAJIT_INCLUDE_DIRS})
   list(APPEND gen_cflags "-I${gen_include}")
 endforeach()
 string(TOUPPER "${CMAKE_BUILD_TYPE}" build_type)
@@ -219,18 +225,34 @@ add_custom_command(OUTPUT ${GENERATED_UNICODE_TABLES}
     ${UNICODE_FILES}
 )
 
-add_custom_command(OUTPUT ${GENERATED_API_DISPATCH} ${GENERATED_FUNCS_METADATA}
-                          ${API_METADATA}
-  COMMAND ${LUA_PRG} ${DISPATCH_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}
-                     ${API_HEADERS} ${GENERATED_API_DISPATCH}
+add_custom_command(
+  OUTPUT ${GENERATED_API_DISPATCH} ${GENERATED_FUNCS_METADATA}
+         ${API_METADATA} ${MSGPACK_LUA_C_BINDINGS}
+  COMMAND ${LUA_PRG} ${MSGPACK_GENERATOR} ${CMAKE_CURRENT_LIST_DIR}
+                     ${GENERATED_API_DISPATCH}
                      ${GENERATED_FUNCS_METADATA} ${API_METADATA}
+                     ${MSGPACK_LUA_C_BINDINGS}
+                     ${API_HEADERS}
   DEPENDS
     ${API_HEADERS}
     ${MSGPACK_RPC_HEADERS}
-    ${DISPATCH_GENERATOR}
+    ${MSGPACK_GENERATOR}
     ${CMAKE_CURRENT_LIST_DIR}/api/dispatch_deprecated.lua
 )
 
+add_custom_command(
+  OUTPUT ${VIM_MODULE_FILE}
+  COMMAND ${LUA_PRG} ${CHAR_BLOB_GENERATOR} ${VIM_MODULE_SOURCE}
+                     ${VIM_MODULE_FILE} vim_module
+  DEPENDS
+    ${CHAR_BLOB_GENERATOR}
+    ${VIM_MODULE_SOURCE}
+)
+
+list(APPEND NVIM_GENERATED_SOURCES
+  "${MSGPACK_LUA_C_BINDINGS}"
+)
+
 list(APPEND NVIM_GENERATED_FOR_HEADERS
   "${GENERATED_EX_CMDS_ENUM}"
   "${GENERATED_EVENTS_ENUM}"
@@ -242,6 +264,7 @@ list(APPEND NVIM_GENERATED_FOR_SOURCES
   "${GENERATED_EVENTS_NAMES_MAP}"
   "${GENERATED_OPTIONS}"
   "${GENERATED_UNICODE_TABLES}"
+  "${VIM_MODULE_FILE}"
 )
 
 list(APPEND NVIM_GENERATED_SOURCES
@@ -315,6 +338,23 @@ if(UNIX)
 endif()
 
 set(NVIM_EXEC_LINK_LIBRARIES ${NVIM_LINK_LIBRARIES})
+set(NVIM_TEST_LINK_LIBRARIES ${NVIM_LINK_LIBRARIES})
+
+if(CMAKE_VERSION VERSION_LESS "2.8.8")
+  if(PREFER_LUAJIT)
+    include_directories(${LUAJIT_INCLUDE_DIRS})
+  else()
+    message(FATAL_ERROR
+            "Must support INCLUDE_DIRECTORIES target property to build")
+  endif()
+endif()
+
+if(PREFER_LUAJIT)
+  list(APPEND NVIM_EXEC_LINK_LIBRARIES ${LUAJIT_LIBRARIES})
+else()
+  list(APPEND NVIM_EXEC_LINK_LIBRARIES ${LUA_LIBRARIES})
+endif()
+list(APPEND NVIM_TEST_LINK_LIBRARIES ${LUAJIT_LIBRARIES})
 
 # Don't use jemalloc in the unit test library.
 if(JEMALLOC_FOUND)
@@ -326,6 +366,14 @@ add_executable(nvim ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
 target_link_libraries(nvim ${NVIM_EXEC_LINK_LIBRARIES})
 install_helper(TARGETS nvim)
 
+if(PREFER_LUAJIT)
+  set(LUA_PREFERRED_INCLUDE_DIRS ${LUAJIT_INCLUDE_DIRS})
+else()
+  set(LUA_PREFERRED_INCLUDE_DIRS ${LUA_INCLUDE_DIRS})
+endif()
+set_property(TARGET nvim APPEND PROPERTY
+             INCLUDE_DIRECTORIES ${LUA_PREFERRED_INCLUDE_DIRS})
+
 if(WIN32)
   # Copy DLLs and third-party tools to bin/ and install them along with nvim
   add_custom_target(nvim_runtime_deps ALL
@@ -372,6 +420,50 @@ if(WIN32)
   add_dependencies(nvim_runtime_deps external_blobs)
 endif()
 
+add_library(
+  libnvim
+  STATIC
+  EXCLUDE_FROM_ALL
+  ${NVIM_SOURCES} ${NVIM_GENERATED_SOURCES}
+  ${NVIM_HEADERS} ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
+)
+set_property(TARGET libnvim APPEND PROPERTY
+             INCLUDE_DIRECTORIES ${LUAJIT_INCLUDE_DIRS})
+target_link_libraries(libnvim ${NVIM_TEST_LINK_LIBRARIES})
+set_target_properties(
+  libnvim
+  PROPERTIES
+    POSITION_INDEPENDENT_CODE ON
+    OUTPUT_NAME nvim
+)
+set_property(
+  TARGET libnvim
+  APPEND_STRING PROPERTY COMPILE_FLAGS " -DMAKE_LIB "
+)
+
+add_library(
+  nvim-test
+  MODULE
+  EXCLUDE_FROM_ALL
+  ${NVIM_SOURCES} ${NVIM_GENERATED_SOURCES}
+  ${NVIM_HEADERS} ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
+  ${UNIT_TEST_FIXTURES}
+)
+target_link_libraries(nvim-test ${NVIM_TEST_LINK_LIBRARIES})
+set_property(
+  TARGET nvim-test
+  APPEND PROPERTY INCLUDE_DIRECTORIES ${LUAJIT_INCLUDE_DIRS}
+)
+set_target_properties(
+  nvim-test
+  PROPERTIES
+    POSITION_INDEPENDENT_CODE ON
+)
+set_property(
+  TARGET nvim-test
+  APPEND_STRING PROPERTY COMPILE_FLAGS " -DUNIT_TESTING "
+)
+
 if(CLANG_ASAN_UBSAN)
   message(STATUS "Enabling Clang address sanitizer and undefined behavior sanitizer for nvim.")
   check_c_compiler_flag(-fno-sanitize-recover=all SANITIZE_RECOVER_ALL)
@@ -396,19 +488,6 @@ elseif(CLANG_TSAN)
   set_property(TARGET nvim APPEND_STRING PROPERTY LINK_FLAGS "-fsanitize=thread ")
 endif()
 
-add_library(libnvim STATIC EXCLUDE_FROM_ALL ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
-  ${NVIM_GENERATED_SOURCES} ${NVIM_SOURCES} ${NVIM_HEADERS})
-target_link_libraries(libnvim ${NVIM_LINK_LIBRARIES})
-set_target_properties(libnvim PROPERTIES
-  POSITION_INDEPENDENT_CODE ON
-  OUTPUT_NAME nvim)
-set_property(TARGET libnvim APPEND_STRING PROPERTY COMPILE_FLAGS " -DMAKE_LIB ")
-
-add_library(nvim-test MODULE EXCLUDE_FROM_ALL ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
-  ${NVIM_GENERATED_SOURCES} ${NVIM_SOURCES} ${UNIT_TEST_FIXTURES} ${NVIM_HEADERS})
-target_link_libraries(nvim-test ${NVIM_LINK_LIBRARIES})
-set_property(TARGET nvim-test APPEND_STRING PROPERTY COMPILE_FLAGS -DUNIT_TESTING)
-
 function(get_test_target prefix sfile relative_path_var target_var)
   get_filename_component(full_d "${sfile}" PATH)
   file(RELATIVE_PATH d "${PROJECT_SOURCE_DIR}/src/nvim" "${full_d}")
@@ -446,6 +525,10 @@ foreach(hfile ${NVIM_HEADERS})
       ${texe}
       EXCLUDE_FROM_ALL
       ${tsource} ${NVIM_HEADERS} ${NVIM_GENERATED_FOR_HEADERS})
+    set_property(
+      TARGET ${texe}
+      APPEND PROPERTY INCLUDE_DIRECTORIES ${LUA_PREFERRED_INCLUDE_DIRS}
+    )
 
     list(FIND NO_SINGLE_CHECK_HEADERS "${relative_path}" hfile_exclude_idx)
     if(${hfile_exclude_idx} EQUAL -1)
diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 5de1535bce..0b8d39d0d2 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -195,7 +195,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
     Object str = STRING_OBJ(cstr_to_string(bufstr));
 
     // Vim represents NULs as NLs, but this may confuse clients.
-    if (channel_id != INTERNAL_CALL) {
+    if (channel_id != VIML_INTERNAL_CALL) {
       strchrsub(str.data.string.data, '\n', '\0');
     }
 
@@ -295,6 +295,24 @@ void nvim_buf_set_lines(uint64_t channel_id,
     return;
   }
 
+  for (size_t i = 0; i < replacement.size; i++) {
+    if (replacement.items[i].type != kObjectTypeString) {
+      api_set_error(err,
+                    kErrorTypeValidation,
+                    "All items in the replacement array must be strings");
+      return;
+    }
+    // Disallow newlines in the middle of the line.
+    if (channel_id != VIML_INTERNAL_CALL) {
+      const String l = replacement.items[i].data.string;
+      if (memchr(l.data, NL, l.size)) {
+        api_set_error(err, kErrorTypeValidation,
+                      "String cannot contain newlines");
+        return;
+      }
+    }
+  }
+
   win_T *save_curwin = NULL;
   tabpage_T *save_curtab = NULL;
   size_t new_len = replacement.size;
@@ -303,27 +321,12 @@ void nvim_buf_set_lines(uint64_t channel_id,
   char **lines = (new_len != 0) ? xcalloc(new_len, sizeof(char *)) : NULL;
 
   for (size_t i = 0; i < new_len; i++) {
-    if (replacement.items[i].type != kObjectTypeString) {
-      api_set_error(err,
-                    kErrorTypeValidation,
-                    "All items in the replacement array must be strings");
-      goto end;
-    }
-
-    String l = replacement.items[i].data.string;
+    const String l = replacement.items[i].data.string;
 
-    // Fill lines[i] with l's contents. Disallow newlines in the middle of a
-    // line and convert NULs to newlines to avoid truncation.
-    lines[i] = xmallocz(l.size);
-    for (size_t j = 0; j < l.size; j++) {
-      if (l.data[j] == '\n' && channel_id != INTERNAL_CALL) {
-        api_set_error(err, kErrorTypeException,
-                      "String cannot contain newlines");
-        new_len = i + 1;
-        goto end;
-      }
-      lines[i][j] = (char) (l.data[j] == '\0' ? '\n' : l.data[j]);
-    }
+    // Fill lines[i] with l's contents. Convert NULs to newlines as required by
+    // NL-used-for-NUL.
+    lines[i] = xmemdupz(l.data, l.size);
+    memchrsub(lines[i], NUL, NL, l.size);
   }
 
   try_start();
diff --git a/src/nvim/api/private/defs.h b/src/nvim/api/private/defs.h
index 60bf38265f..2144c80d6a 100644
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -5,6 +5,8 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "nvim/func_attr.h"
+
 #define ARRAY_DICT_INIT {.size = 0, .capacity = 0, .items = NULL}
 #define STRING_INIT {.data = NULL, .size = 0}
 #define OBJECT_INIT { .type = kObjectTypeNil }
@@ -36,8 +38,27 @@ typedef enum {
 /// Used as the message ID of notifications.
 #define NO_RESPONSE UINT64_MAX
 
-/// Used as channel_id when the call is local.
-#define INTERNAL_CALL UINT64_MAX
+/// Mask for all internal calls
+#define INTERNAL_CALL_MASK (((uint64_t)1) << (sizeof(uint64_t) * 8 - 1))
+
+/// Internal call from VimL code
+#define VIML_INTERNAL_CALL INTERNAL_CALL_MASK
+
+/// Internal call from lua code
+#define LUA_INTERNAL_CALL (VIML_INTERNAL_CALL + 1)
+
+static inline bool is_internal_call(uint64_t channel_id)
+  REAL_FATTR_ALWAYS_INLINE REAL_FATTR_CONST;
+
+/// Check whether call is internal
+///
+/// @param[in]  channel_id  Channel id.
+///
+/// @return true if channel_id refers to internal channel.
+static inline bool is_internal_call(const uint64_t channel_id)
+{
+  return !!(channel_id & INTERNAL_CALL_MASK);
+}
 
 typedef struct {
   ErrorType type;
@@ -78,16 +99,17 @@ typedef struct {
 } Dictionary;
 
 typedef enum {
-  kObjectTypeBuffer,
-  kObjectTypeWindow,
-  kObjectTypeTabpage,
-  kObjectTypeNil,
+  kObjectTypeNil = 0,
   kObjectTypeBoolean,
   kObjectTypeInteger,
   kObjectTypeFloat,
   kObjectTypeString,
   kObjectTypeArray,
   kObjectTypeDictionary,
+  // EXT types, cannot be split or reordered, see #EXT_OBJECT_TYPE_SHIFT
+  kObjectTypeBuffer,
+  kObjectTypeWindow,
+  kObjectTypeTabpage,
 } ObjectType;
 
 struct object {
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index 69cb19c14f..4cc4b600d5 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -353,7 +353,7 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
 #define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER TYPVAL_ENCODE_CONV_NUMBER
 
 #define TYPVAL_ENCODE_CONV_FLOAT(tv, flt) \
-    kv_push(edata->stack, FLOATING_OBJ((Float)(flt)))
+    kv_push(edata->stack, FLOAT_OBJ((Float)(flt)))
 
 #define TYPVAL_ENCODE_CONV_STRING(tv, str, len) \
     do { \
@@ -864,15 +864,18 @@ static void init_type_metadata(Dictionary *metadata)
   Dictionary types = ARRAY_DICT_INIT;
 
   Dictionary buffer_metadata = ARRAY_DICT_INIT;
-  PUT(buffer_metadata, "id", INTEGER_OBJ(kObjectTypeBuffer));
+  PUT(buffer_metadata, "id",
+      INTEGER_OBJ(kObjectTypeBuffer - EXT_OBJECT_TYPE_SHIFT));
   PUT(buffer_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_buf_")));
 
   Dictionary window_metadata = ARRAY_DICT_INIT;
-  PUT(window_metadata, "id", INTEGER_OBJ(kObjectTypeWindow));
+  PUT(window_metadata, "id",
+      INTEGER_OBJ(kObjectTypeWindow - EXT_OBJECT_TYPE_SHIFT));
   PUT(window_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_win_")));
 
   Dictionary tabpage_metadata = ARRAY_DICT_INIT;
-  PUT(tabpage_metadata, "id", INTEGER_OBJ(kObjectTypeTabpage));
+  PUT(tabpage_metadata, "id",
+      INTEGER_OBJ(kObjectTypeTabpage - EXT_OBJECT_TYPE_SHIFT));
   PUT(tabpage_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_tabpage_")));
 
   PUT(types, "Buffer", DICTIONARY_OBJ(buffer_metadata));
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index 681945ac9c..159b9d5c2a 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -18,7 +18,7 @@
     .type = kObjectTypeInteger, \
     .data.integer = i })
 
-#define FLOATING_OBJ(f) ((Object) { \
+#define FLOAT_OBJ(f) ((Object) { \
     .type = kObjectTypeFloat, \
     .data.floating = f })
 
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 11f15b5ad1..12e8194c15 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -144,7 +144,7 @@ String nvim_replace_termcodes(String str, Boolean from_part, Boolean do_lt,
 {
   if (str.size == 0) {
     // Empty string
-    return str;
+    return (String) { .data = NULL, .size = 0 };
   }
 
   char *ptr = NULL;
@@ -203,7 +203,8 @@ Object nvim_eval(String expr, Error *err)
   return rv;
 }
 
-/// Calls a VimL function with the given arguments.
+/// Calls a VimL function with the given arguments
+///
 /// On VimL error: Returns a generic error; v:errmsg is not updated.
 ///
 /// @param fname    Function to call
@@ -855,3 +856,57 @@ static void write_msg(String message, bool to_err)
   --no_wait_return;
   msg_end();
 }
+
+// Functions used for testing purposes
+
+/// Returns object given as argument
+///
+/// This API function is used for testing. One should not rely on its presence
+/// in plugins.
+///
+/// @param[in]  obj  Object to return.
+///
+/// @return its argument.
+Object nvim__id(Object obj)
+{
+  return copy_object(obj);
+}
+
+/// Returns array given as argument
+///
+/// This API function is used for testing. One should not rely on its presence
+/// in plugins.
+///
+/// @param[in]  arr  Array to return.
+///
+/// @return its argument.
+Array nvim__id_array(Array arr)
+{
+  return copy_object(ARRAY_OBJ(arr)).data.array;
+}
+
+/// Returns dictionary given as argument
+///
+/// This API function is used for testing. One should not rely on its presence
+/// in plugins.
+///
+/// @param[in]  dct  Dictionary to return.
+///
+/// @return its argument.
+Dictionary nvim__id_dictionary(Dictionary dct)
+{
+  return copy_object(DICTIONARY_OBJ(dct)).data.dictionary;
+}
+
+/// Returns floating-point value given as argument
+///
+/// This API function is used for testing. One should not rely on its presence
+/// in plugins.
+///
+/// @param[in]  flt  Value to return.
+///
+/// @return its argument.
+Float nvim__id_float(Float flt)
+{
+  return flt;
+}
diff --git a/src/nvim/api/window.c b/src/nvim/api/window.c
index 859bf88398..22902800ea 100644
--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -62,6 +62,10 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
 {
   win_T *win = find_window_by_handle(window, err);
 
+  if (!win) {
+    return;
+  }
+
   if (pos.size != 2 || pos.items[0].type != kObjectTypeInteger
       || pos.items[1].type != kObjectTypeInteger) {
     api_set_error(err,
@@ -70,10 +74,6 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
     return;
   }
 
-  if (!win) {
-    return;
-  }
-
   int64_t row = pos.items[0].data.integer;
   int64_t col = pos.items[1].data.integer;
 
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 1bf85ccd8b..56a6632fad 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -97,6 +97,7 @@
 #include "nvim/lib/kvec.h"
 #include "nvim/lib/khash.h"
 #include "nvim/lib/queue.h"
+#include "nvim/lua/executor.h"
 #include "nvim/eval/typval.h"
 #include "nvim/eval/executor.h"
 #include "nvim/eval/gc.h"
@@ -6510,7 +6511,7 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   Error err = ERROR_INIT;
-  Object result = fn(INTERNAL_CALL, args, &err);
+  Object result = fn(VIML_INTERNAL_CALL, args, &err);
 
   if (ERROR_SET(&err)) {
     nvim_err_writeln(cstr_as_string(err.msg));
@@ -10973,7 +10974,9 @@ static int inputsecret_flag = 0;
  * prompt. The third argument to f_inputdialog() specifies the value to return
  * when the user cancels the prompt.
  */
-static void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog)
+void get_user_input(const typval_T *const argvars,
+                    typval_T *const rettv, const bool inputdialog)
+  FUNC_ATTR_NONNULL_ALL
 {
   const char *prompt = tv_get_string_chk(&argvars[0]);
   int cmd_silent_save = cmd_silent;
@@ -12076,6 +12079,18 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
   }
 }
 
+/// luaeval() function implementation
+static void f_luaeval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+  FUNC_ATTR_NONNULL_ALL
+{
+  const char *const str = (const char *)tv_get_string_chk(&argvars[0]);
+  if (str == NULL) {
+    return;
+  }
+
+  executor_eval_lua(cstr_as_string((char *)str), &argvars[1], rettv);
+}
+
 /*
  * "map()" function
  */
diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index 21b5bbb139..533403b2b0 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -193,6 +193,7 @@ return {
     localtime={},
     log={args=1, func="float_op_wrapper", data="&log"},
     log10={args=1, func="float_op_wrapper", data="&log10"},
+    luaeval={args={1, 2}},
     map={args=2},
     maparg={args={1, 4}},
     mapcheck={args={1, 3}},
diff --git a/src/nvim/eval/decode.c b/src/nvim/eval/decode.c
index 8905317f15..935c98fb84 100644
--- a/src/nvim/eval/decode.c
+++ b/src/nvim/eval/decode.c
@@ -11,6 +11,7 @@
 #include "nvim/ascii.h"
 #include "nvim/macros.h"
 #include "nvim/message.h"
+#include "nvim/globals.h"
 #include "nvim/charset.h"  // vim_str2nr
 #include "nvim/lib/kvec.h"
 #include "nvim/vim.h"  // OK, FAIL
@@ -223,6 +224,78 @@ static inline int json_decoder_pop(ValuesStackItem obj,
     } \
   } while (0)
 
+/// Create a new special dictionary that ought to represent a MAP
+///
+/// @param[out]  ret_tv  Address where new special dictionary is saved.
+///
+/// @return [allocated] list which should contain key-value pairs. Return value
+///                     may be safely ignored.
+list_T *decode_create_map_special_dict(typval_T *const ret_tv)
+  FUNC_ATTR_NONNULL_ALL
+{
+  list_T *const list = tv_list_alloc();
+  list->lv_refcount++;
+  create_special_dict(ret_tv, kMPMap, ((typval_T) {
+    .v_type = VAR_LIST,
+    .v_lock = VAR_UNLOCKED,
+    .vval = { .v_list = list },
+  }));
+  return list;
+}
+
+/// Convert char* string to typval_T
+///
+/// Depending on whether string has (no) NUL bytes, it may use a special
+/// dictionary or decode string to VAR_STRING.
+///
+/// @param[in]  s  String to decode.
+/// @param[in]  len  String length.
+/// @param[in]  hasnul  Whether string has NUL byte, not or it was not yet
+///                     determined.
+/// @param[in]  binary  If true, save special string type as kMPBinary,
+///                     otherwise kMPString.
+/// @param[in]  s_allocated  If true, then `s` was allocated and can be saved in
+///                          a returned structure. If it is not saved there, it
+///                          will be freed.
+///
+/// @return Decoded string.
+typval_T decode_string(const char *const s, const size_t len,
+                       const TriState hasnul, const bool binary,
+                       const bool s_allocated)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  assert(s != NULL || len == 0);
+  const bool really_hasnul = (hasnul == kNone
+                              ? memchr(s, NUL, len) != NULL
+                              : (bool)hasnul);
+  if (really_hasnul) {
+    list_T *const list = tv_list_alloc();
+    list->lv_refcount++;
+    typval_T tv;
+    create_special_dict(&tv, binary ? kMPBinary : kMPString, ((typval_T) {
+      .v_type = VAR_LIST,
+      .v_lock = VAR_UNLOCKED,
+      .vval = { .v_list = list },
+    }));
+    const int elw_ret = encode_list_write((void *)list, s, len);
+    if (s_allocated) {
+      xfree((void *)s);
+    }
+    if (elw_ret == -1) {
+      tv_clear(&tv);
+      return (typval_T) { .v_type = VAR_UNKNOWN, .v_lock = VAR_UNLOCKED };
+    }
+    return tv;
+  } else {
+    return (typval_T) {
+      .v_type = VAR_STRING,
+      .v_lock = VAR_UNLOCKED,
+      .vval = { .v_string = (char_u *)(
+          s_allocated ? (char *)s : xmemdupz(s, len)) },
+    };
+  }
+}
+
 /// Parse JSON double-quoted string
 ///
 /// @param[in]  buf  Buffer being converted.
@@ -416,29 +489,13 @@ static inline int parse_json_string(const char *const buf, const size_t buf_len,
   }
   PUT_FST_IN_PAIR(fst_in_pair, str_end);
 #undef PUT_FST_IN_PAIR
-  if (hasnul) {
-    typval_T obj;
-    list_T *const list = tv_list_alloc();
-    list->lv_refcount++;
-    create_special_dict(&obj, kMPString, ((typval_T) {
-      .v_type = VAR_LIST,
-      .v_lock = VAR_UNLOCKED,
-      .vval = { .v_list = list },
-    }));
-    if (encode_list_write((void *) list, str, (size_t) (str_end - str))
-        == -1) {
-      tv_clear(&obj);
-      goto parse_json_string_fail;
-    }
-    xfree(str);
-    POP(obj, true);
-  } else {
-    *str_end = NUL;
-    POP(((typval_T) {
-      .v_type = VAR_STRING,
-      .vval = { .v_string = (char_u *) str },
-    }), false);
+  *str_end = NUL;
+  typval_T obj = decode_string(
+      str, (size_t)(str_end - str), hasnul ? kTrue : kFalse, false, true);
+  if (obj.v_type == VAR_UNKNOWN) {
+    goto parse_json_string_fail;
   }
+  POP(obj, obj.v_type != VAR_STRING);
   goto parse_json_string_ret;
 parse_json_string_fail:
   ret = FAIL;
@@ -812,13 +869,7 @@ json_decode_string_cycle_start:
         list_T *val_list = NULL;
         if (next_map_special) {
           next_map_special = false;
-          val_list = tv_list_alloc();
-          val_list->lv_refcount++;
-          create_special_dict(&tv, kMPMap, ((typval_T) {
-            .v_type = VAR_LIST,
-            .v_lock = VAR_UNLOCKED,
-            .vval = { .v_list = val_list },
-          }));
+          val_list = decode_create_map_special_dict(&tv);
         } else {
           dict_T *dict = tv_dict_alloc();
           dict->dv_refcount++;
@@ -971,37 +1022,17 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
       break;
     }
     case MSGPACK_OBJECT_STR: {
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPString, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
-      if (encode_list_write((void *) list, mobj.via.str.ptr, mobj.via.str.size)
-          == -1) {
+      *rettv = decode_string(mobj.via.bin.ptr, mobj.via.bin.size, kTrue, false,
+                             false);
+      if (rettv->v_type == VAR_UNKNOWN) {
         return FAIL;
       }
       break;
     }
     case MSGPACK_OBJECT_BIN: {
-      if (memchr(mobj.via.bin.ptr, NUL, mobj.via.bin.size) == NULL) {
-        *rettv = (typval_T) {
-          .v_type = VAR_STRING,
-          .v_lock = VAR_UNLOCKED,
-          .vval = { .v_string = xmemdupz(mobj.via.bin.ptr, mobj.via.bin.size) },
-        };
-        break;
-      }
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPBinary, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
-      if (encode_list_write((void *) list, mobj.via.bin.ptr, mobj.via.bin.size)
-          == -1) {
+      *rettv = decode_string(mobj.via.bin.ptr, mobj.via.bin.size, kNone, true,
+                             false);
+      if (rettv->v_type == VAR_UNKNOWN) {
         return FAIL;
       }
       break;
@@ -1058,13 +1089,7 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
       }
       break;
 msgpack_to_vim_generic_map: {}
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPMap, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
+      list_T *const list = decode_create_map_special_dict(rettv);
       for (size_t i = 0; i < mobj.via.map.size; i++) {
         list_T *const kv_pair = tv_list_alloc();
         tv_list_append_list(list, kv_pair);
diff --git a/src/nvim/eval/decode.h b/src/nvim/eval/decode.h
index c8e7a189e3..77fc4c78c2 100644
--- a/src/nvim/eval/decode.h
+++ b/src/nvim/eval/decode.h
@@ -6,6 +6,7 @@
 #include <msgpack.h>
 
 #include "nvim/eval/typval.h"
+#include "nvim/globals.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval/decode.h.generated.h"
diff --git a/src/nvim/eval/typval_encode.c.h b/src/nvim/eval/typval_encode.c.h
index b4a70fb188..a93ad2dbba 100644
--- a/src/nvim/eval/typval_encode.c.h
+++ b/src/nvim/eval/typval_encode.c.h
@@ -233,10 +233,6 @@
 ///
 /// This name will only be used by one of the above macros which are defined by
 /// the caller. Functions defined here do not use first argument directly.
-#ifndef NVIM_EVAL_TYPVAL_ENCODE_C_H
-#define NVIM_EVAL_TYPVAL_ENCODE_C_H
-#undef NVIM_EVAL_TYPVAL_ENCODE_C_H
-
 #include <stddef.h>
 #include <inttypes.h>
 #include <assert.h>
@@ -816,4 +812,3 @@ encode_vim_to__error_ret:
   // Prevent “unused label” warnings.
   goto typval_encode_stop_converting_one_item;  // -V779
 }
-#endif  // NVIM_EVAL_TYPVAL_ENCODE_C_H
diff --git a/src/nvim/ex_cmds.lua b/src/nvim/ex_cmds.lua
index 523740444d..7203fbd97d 100644
--- a/src/nvim/ex_cmds.lua
+++ b/src/nvim/ex_cmds.lua
@@ -1548,19 +1548,19 @@ return {
     command='lua',
     flags=bit.bor(RANGE, EXTRA, NEEDARG, CMDWIN),
     addr_type=ADDR_LINES,
-    func='ex_script_ni