treewide: make the entire generated config lua based

lib/dag.nix

@@ -146,9 +146,4 @@ in {
     -- SECTION: ${section.name}
     ${section.data}
   '';
-
-  mkVimrcSection = section: ''
-    " SECTION: ${section.name}
-    ${section.data}
-  '';
 }

lib/default.nix

@@ -11,6 +11,5 @@
   languages = import ./languages.nix {inherit lib;};
   lists = import ./lists.nix {inherit lib;};
   lua = import ./lua.nix {inherit lib;};
-  vim = import ./vim.nix;
   neovimConfiguration = import ./configuration.nix {inherit inputs lib;};
 }

lib/lua.nix

@@ -5,16 +5,6 @@
   inherit (lib.strings) concatStringsSep concatMapStringsSep stringToCharacters concatLines;
   inherit (lib.trivial) boolToString warn;
 in rec {
-  wrapLuaConfig = {
-    luaBefore ? "",
-    luaConfig,
-    luaAfter ? "",
-  }: ''
-    lua << EOF
-    ${concatLines [luaBefore luaConfig luaAfter]}
-    EOF
-  '';
-
   # Convert a null value to lua's nil
   nullString = value:
     if value == null

lib/vim.nix

@@ -1,26 +0,0 @@
-let
-  inherit (builtins) isInt isBool toJSON toString;
-in rec {
-  # yes? no.
-  yesNo = value:
-    if value
-    then "yes"
-    else "no";
-
-  # convert a boolean to a vim compliant boolean string
-  mkVimBool = val:
-    if val
-    then "1"
-    else "0";
-
-  # convert a literal value to a vim compliant value
-  valToVim = val:
-    if (isInt val)
-    then (toString val)
-    else
-      (
-        if (isBool val)
-        then (mkVimBool val)
-        else (toJSON val)
-      );
-}

modules/default.nix

@@ -98,8 +98,9 @@ inputs: {
     neovim = vimOptions.package;
     plugins = concatLists [builtStartPlugins builtOptPlugins];
     appName = "nvf";
-    initViml = vimOptions.builtConfigRC;
     extraBinPath = vimOptions.extraPackages;
+    initLua = vimOptions.builtLuaConfigRC;
+    luaFiles = vimOptions.extraLuaFiles;
 
     inherit (vimOptions) viAlias vimAlias withRuby withNodeJs withPython3;
     inherit extraLuaPackages extraPython3Packages;

modules/neovim/init/basic.nix

@@ -5,16 +5,17 @@
 }: let
   inherit (lib.options) mkOption literalExpression;
   inherit (lib.strings) optionalString;
-  inherit (lib.types) enum bool str int nullOr;
+  inherit (lib.types) enum bool str int ;
   inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.lua) toLuaObject;
 
   cfg = config.vim;
 in {
   options.vim = {
     leaderKey = mkOption {
-      type = nullOr str;
-      default = null;
-      description = "The leader key to be used internally";
+      type = str;
+      default = " ";
+      description = "The leader key used for `<leader>` mappings";
     };
 
     colourTerm = mkOption {
@@ -53,12 +54,6 @@ in {
       description = "Enable syntax highlighting";
     };
 
-    mapLeaderSpace = mkOption {
-      type = bool;
-      default = true;
-      description = "Map the space key to leader key";
-    };
-
     useSystemClipboard = mkOption {
       type = bool;
       default = false;
@@ -165,117 +160,110 @@ in {
     };
   };
 
-  config.vim.configRC.basic = entryAfter ["globalsScript"] ''
-    " Settings that are set for everything
-    set encoding=utf-8
-    set hidden
-    set shortmess+=c
-    set expandtab
-    set mouse=${cfg.mouseSupport}
-    set tabstop=${toString cfg.tabWidth}
-    set shiftwidth=${toString cfg.tabWidth}
-    set softtabstop=${toString cfg.tabWidth}
-    set cmdheight=${toString cfg.cmdHeight}
-    set updatetime=${toString cfg.updateTime}
-    set tm=${toString cfg.mapTimeout}
-    set cursorlineopt=${toString cfg.cursorlineOpt}
-    set scrolloff=${toString cfg.scrollOffset}
+  config.vim.luaConfigRC.basic = entryAfter ["globalsScript"] ''
+    -- Settings that are set for everything
+    vim.o.encoding = "utf-8"
+    vim.o.hidden = true
+    vim.opt.shortmess:append("c")
+    vim.o.expandtab = true
+    vim.o.mouse = ${toLuaObject cfg.mouseSupport}
+    vim.o.tabstop = ${toLuaObject cfg.tabWidth}
+    vim.o.shiftwidth = ${toLuaObject cfg.tabWidth}
+    vim.o.softtabstop = ${toLuaObject cfg.tabWidth}
+    vim.o.cmdheight = ${toLuaObject cfg.cmdHeight}
+    vim.o.updatetime = ${toLuaObject cfg.updateTime}
+    vim.o.tm = ${toLuaObject cfg.mapTimeout}
+    vim.o.cursorlineopt = ${toLuaObject cfg.cursorlineOpt}
+    vim.o.scrolloff = ${toLuaObject cfg.scrollOffset}
+    vim.g.mapleader = ${toLuaObject cfg.leaderKey}
+    vim.g.maplocalleader = ${toLuaObject cfg.leaderKey}
 
     ${optionalString cfg.splitBelow ''
-      set splitbelow
+      vim.o.splitbelow = true
     ''}
 
     ${optionalString cfg.splitRight ''
-      set splitright
+      vim.o.splitright = true
     ''}
 
     ${optionalString cfg.showSignColumn ''
-      set signcolumn=yes
+      vim.o.signcolumn = "yes"
     ''}
 
     ${optionalString cfg.autoIndent ''
-      set autoindent
+      vim.o.autoindent = true
     ''}
 
     ${optionalString cfg.preventJunkFiles ''
-      set noswapfile
-      set nobackup
-      set nowritebackup
+      vim.o.swapfile = false
+      vim.o.backup = false
+      vim.o.writebackup = false
     ''}
 
     ${optionalString (cfg.bell == "none") ''
-      set noerrorbells
-      set novisualbell
+      vim.o.errorbells = false
+      vim.o.visualbell = false
     ''}
 
     ${optionalString (cfg.bell == "on") ''
-      set novisualbell
+      vim.o.visualbell = false
     ''}
 
     ${optionalString (cfg.bell == "visual") ''
-      set noerrorbells
+      vim.o.errorbells = false
     ''}
 
     ${optionalString (cfg.lineNumberMode == "relative") ''
-      set relativenumber
+      vim.o.relativenumber = true
     ''}
 
     ${optionalString (cfg.lineNumberMode == "number") ''
-      set number
+      vim.o.number = true
     ''}
 
     ${optionalString (cfg.lineNumberMode == "relNumber") ''
-      set number relativenumber
+      vim.o.number = true
+      vim.o.relativenumber = true
     ''}
 
     ${optionalString cfg.useSystemClipboard ''
-      set clipboard+=unnamedplus
-    ''}
-
-    ${optionalString cfg.mapLeaderSpace ''
-      let mapleader=" "
-      let maplocalleader=" "
+      vim.opt.clipboard:append("unnamedplus")
     ''}
 
     ${optionalString cfg.syntaxHighlighting ''
-      syntax on
+      vim.cmd("syntax on")
     ''}
 
     ${optionalString (!cfg.wordWrap) ''
-      set nowrap
+      vim.o.wrap = false
     ''}
 
     ${optionalString cfg.hideSearchHighlight ''
-      set nohlsearch
-      set incsearch
+      vim.o.hlsearch = false
+      vim.o.incsearch = true
     ''}
 
     ${optionalString cfg.colourTerm ''
-      set termguicolors
-      set t_Co=256
+      vim.o.termguicolors = true
     ''}
 
     ${optionalString (!cfg.enableEditorconfig) ''
-      let g:editorconfig = v:false
-    ''}
-
-    ${optionalString (cfg.leaderKey != null) ''
-      let mapleader = "${toString cfg.leaderKey}"
+      vim.g.editorconfig = false
     ''}
 
     ${optionalString (cfg.searchCase == "ignore") ''
-      set nosmartcase
-      set ignorecase
+      vim.o.smartcase = false
+      vim.o.ignorecase = true
     ''}
 
     ${optionalString (cfg.searchCase == "smart") ''
-      set smartcase
-      set ignorecase
+      vim.o.smartcase = true
+      vim.o.ignorecase = true
     ''}
 
     ${optionalString (cfg.searchCase == "sensitive") ''
-      set nosmartcase
-      set noignorecase
+      vim.o.smartcase = false
+      vim.o.ignorecase = false
     ''}
   '';
 }

modules/neovim/mappings/config.nix

@@ -9,8 +9,7 @@
 in {
   config = {
     vim.maps = {
-      normal =
-        mkIf cfg.disableArrows {
+      normal = mkIf cfg.disableArrows {
         "<up>" = {
           action = "<nop>";
 
@@ -29,11 +28,6 @@ in {
           action = "<nop>";
           noremap = false;
         };
-        }
-        // mkIf cfg.mapLeaderSpace {
-          "<space>" = {
-            action = "<nop>";
-          };
       };
 
       insert = mkIf cfg.disableArrows {

modules/plugins/dashboard/startify/config.nix

@@ -5,7 +5,6 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.vim) mkVimBool;
 
   cfg = config.vim.dashboard.startify;
 in {
@@ -23,28 +22,28 @@ in {
         else cfg.customFooter;
       "startify_bookmarks" = cfg.bookmarks;
       "startify_lists" = cfg.lists;
-      "startify_change_to_dir" = mkVimBool cfg.changeToDir;
-      "startify_change_to_vcs_root" = mkVimBool cfg.changeToVCRoot;
+      "startify_change_to_dir" = cfg.changeToDir;
+      "startify_change_to_vcs_root" = cfg.changeToVCRoot;
       "startify_change_cmd" = cfg.changeDirCmd;
       "startify_skiplist" = cfg.skipList;
-      "startify_update_oldfiles" = mkVimBool cfg.updateOldFiles;
-      "startify_session_autoload" = mkVimBool cfg.sessionAutoload;
+      "startify_update_oldfiles" = cfg.updateOldFiles;
+      "startify_session_autoload" = cfg.sessionAutoload;
       "startify_commands" = cfg.commands;
       "startify_files_number" = cfg.filesNumber;
       "startify_custom_indices" = cfg.customIndices;
-      "startify_disable_at_vimenter" = mkVimBool cfg.disableOnStartup;
-      "startify_enable_unsafe" = mkVimBool cfg.unsafe;
+      "startify_disable_at_vimenter" = cfg.disableOnStartup;
+      "startify_enable_unsafe" = cfg.unsafe;
       "startify_padding_left" = cfg.paddingLeft;
-      "startify_use_env" = mkVimBool cfg.useEnv;
+      "startify_use_env" = cfg.useEnv;
       "startify_session_before_save" = cfg.sessionBeforeSave;
-      "startify_session_persistence" = mkVimBool cfg.sessionPersistence;
-      "startify_session_delete_buffers" = mkVimBool cfg.sessionDeleteBuffers;
+      "startify_session_persistence" = cfg.sessionPersistence;
+      "startify_session_delete_buffers" = cfg.sessionDeleteBuffers;
       "startify_session_dir" = cfg.sessionDir;
       "startify_skiplist_server" = cfg.skipListServer;
       "startify_session_remove_lines" = cfg.sessionRemoveLines;
       "startify_session_savevars" = cfg.sessionSavevars;
       "startify_session_savecmds" = cfg.sessionSavecmds;
-      "startify_session_sort" = mkVimBool cfg.sessionSort;
+      "startify_session_sort" = cfg.sessionSort;
     };
   };
 }

modules/plugins/languages/clang.nix

@@ -12,7 +12,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.dag) entryAfter;
 
   packageToCmd = package: defaultCmd:
     if isList cfg.lsp.package
@@ -141,7 +141,7 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.cHeader {
-      vim.configRC.c-header = entryAnywhere "let g:c_syntax_for_h = 1";
+      vim.luaConfigRC.c-header = entryAfter ["basic"] "vim.g.c_syntax_for_h = 1";
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/nix.nix

@@ -176,8 +176,16 @@ in {
 
   config = mkIf cfg.enable (mkMerge [
     {
-      vim.configRC.nix = entryAnywhere ''
-        autocmd filetype nix setlocal tabstop=2 shiftwidth=2 softtabstop=2
+      vim.luaConfigRC.nix = ''
+        vim.api.nvim_create_autocmd("FileType", {
+          pattern = "nix",
+          callback = function(opts)
+            bo = vim.bo[opts.buf]
+            bo.tabstop = 2
+            bo.shiftwidth = 2
+            bo.softtabstop = 2
+          end
+        })
       '';
     }
 

modules/plugins/theme/theme.nix

@@ -7,10 +7,10 @@
   inherit (lib.attrsets) attrNames;
   inherit (lib.types) bool lines enum;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.dag) entryAfter;
 
   cfg = config.vim.theme;
-  supported_themes = import ./supported_themes.nix {
+  supportedThemes = import ./supported-themes.nix {
     inherit lib config;
   };
 in {
@@ -21,12 +21,12 @@ in {
     };
 
     name = mkOption {
-      type = enum (attrNames supported_themes);
-      description = "Supported themes can be found in `supported_themes.nix`";
+      type = enum (attrNames supportedThemes);
+      description = "Supported themes can be found in `supportedThemes.nix`";
     };
 
     style = mkOption {
-      type = enum supported_themes.${cfg.name}.styles;
+      type = enum supportedThemes.${cfg.name}.styles;
       description = "Specific style for theme if it supports it";
     };
 
@@ -45,11 +45,9 @@ in {
   config = mkIf cfg.enable {
     vim = {
       startPlugins = [cfg.name];
-      configRC.theme = entryBefore ["luaScript"] ''
-        lua << EOF
+      luaConfigRC.theme = entryAfter ["basic"] ''
         ${cfg.extraConfig}
-        ${supported_themes.${cfg.name}.setup (with cfg; {inherit style transparent;})}
-        EOF
+        ${supportedThemes.${cfg.name}.setup {inherit (cfg) style transparent;}}
       '';
     };
   };

modules/plugins/treesitter/config.nix

@@ -37,15 +37,16 @@ in {
       };
 
       # For some reason treesitter highlighting does not work on start if this is set before syntax on
-      configRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
-        " This is required by treesitter-context to handle folds
-        set foldmethod=expr
-        set foldexpr=nvim_treesitter#foldexpr()
+      # HACK: is there a way to convert the foldexpr line to lua?
+      luaConfigRC.treesitter-fold = mkIf cfg.fold (entryBefore ["basic"] ''
+        -- This is required by treesitter-context to handle folds
+        vim.o.foldmethod = "expr"
+        vim.cmd("set foldexpr=nvim_treesitter#foldexpr())"
 
-        " This is optional, but is set rather as a sane default.
-        " If unset, opened files will be folded by automatically as
-        " the files are opened
-        set nofoldenable
+        -- This is optional, but is set rather as a sane default.
+        -- If unset, opened files will be folded by automatically as
+        -- the files are opened
+        vim.o.foldenable = false
       '');
 
       luaConfigRC.treesitter = entryAfter ["basic"] ''

modules/plugins/utility/preview/markdown-preview/config.nix

@@ -4,25 +4,23 @@
   lib,
   ...
 }: let
-  inherit (lib.strings) optionalString stringLength concatMapStringsSep;
+  inherit (lib.strings) stringLength concatMapStringsSep;
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.vim) mkVimBool;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.preview.markdownPreview;
 in {
   config = mkIf cfg.enable {
     vim.startPlugins = [pkgs.vimPlugins.markdown-preview-nvim];
 
-    vim.configRC.markdown-preview = entryAnywhere ''
-      let g:mkdp_auto_start = ${mkVimBool cfg.autoStart}
-      let g:mkdp_auto_close = ${mkVimBool cfg.autoClose}
-      let g:mkdp_refresh_slow = ${mkVimBool cfg.lazyRefresh}
-      let g:mkdp_filetypes = [${concatMapStringsSep ", " (x: "'" + x + "'") cfg.filetypes}]
-      let g:mkdp_command_for_global = ${mkVimBool cfg.alwaysAllowPreview}
-      let g:mkdp_open_to_the_world = ${mkVimBool cfg.broadcastServer}
-      ${optionalString (stringLength cfg.customIP > 0) "let g:mkdp_open_ip = '${cfg.customIP}'"}
-      ${optionalString (stringLength cfg.customPort > 0) "let g:mkdp_port = '${cfg.customPort}'"}
-    '';
+    vim.globals = {
+      mkdp_auto_start = cfg.autoStart;
+      mkdp_auto_close = cfg.autoClose;
+      mkdp_refresh_slow = cfg.lazyRefresh;
+      mkdp_filetypes = [(concatMapStringsSep ", " (x: "'" + x + "'") cfg.filetypes)];
+      mkdp_command_for_global = cfg.alwaysAllowPreview;
+      mkdp_open_to_the_world = cfg.broadcastServer;
+      mkdp_open_ip = mkIf (stringLength cfg.customIP > 0) cfg.customIP;
+      mkdp_port = mkIf (stringLength cfg.customPort > 0) cfg.customPort;
+    };
   };
 }

modules/plugins/utility/wakatime/config.nix

@@ -5,21 +5,14 @@
   ...
 }: let
   inherit (lib.modules) mkIf;
-  inherit (lib.nvim.dag) entryAnywhere;
 
   cfg = config.vim.utility.vim-wakatime;
 in {
   config = mkIf cfg.enable {
-    vim.startPlugins = [
-      pkgs.vimPlugins.vim-wakatime
-    ];
+    vim.startPlugins = [pkgs.vimPlugins.vim-wakatime];
 
-    vim.configRC.vim-wakatime = entryAnywhere ''
-      ${
-        if cfg.cli-package == null
-        then ""
-        else ''let g:wakatime_CLIPath = "${cfg.cli-package}"''
-      }
+    vim.luaConfigRC.vim-wakatime = mkIf (cfg.cli-package != null) ''
+      vim.g.wakatime_CLIPath = "${cfg.cli-package}"
     '';
   };
 }

modules/wrapper/rc/config.nix

@@ -11,9 +11,8 @@
   inherit (lib.trivial) showWarnings;
   inherit (lib.types) str nullOr;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.dag) entryAnywhere entryAfter topoSort mkLuarcSection mkVimrcSection;
-  inherit (lib.nvim.lua) toLuaObject wrapLuaConfig;
-  inherit (lib.nvim.vim) valToVim;
+  inherit (lib.nvim.dag) entryAnywhere entryAfter topoSort mkLuarcSection;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.config) mkBool;
 
   cfg = config.vim;
@@ -82,9 +81,9 @@
       maps);
 in {
   config = let
-    filterNonNull = mappings: filterAttrs (_name: value: value != null) mappings;
+    filterNonNull = attrs: filterAttrs (_: value: value != null) attrs;
     globalsScript =
-      mapAttrsFlatten (name: value: "let g:${name}=${valToVim value}")
+      mapAttrsFlatten (name: value: "vim.g.${name} = ${toLuaObject value}")
       (filterNonNull cfg.globals);
 
     toLuaBindings = mode: maps:
@@ -123,59 +122,13 @@ in {
         else abort ("Dependency cycle in ${name}: " + toJSON sortedDag);
     in
       result;
-  in {
-    vim = {
-      configRC = {
-        globalsScript = entryAnywhere (concatLines globalsScript);
 
-        # Call additional lua files with :luafile in Vimscript
-        # section of the configuration, only after
-        # the luaScript section  has been evaluated
-        extraLuaFiles = let
-          callLuaFiles = map (file: "luafile ${file}") cfg.extraLuaFiles;
-        in
-          entryAfter ["globalScript"] (concatLines callLuaFiles);
-
-        # wrap the lua config in a lua block
-        # using the wrapLuaConfic function from the lib
-        luaScript = let
-          mapResult = result: (wrapLuaConfig {
-            luaBefore = "${cfg.luaConfigPre}";
-            luaConfig = concatLines (map mkLuarcSection result);
-            luaAfter = "${cfg.luaConfigPost}";
-          });
-
-          luaConfig = resolveDag {
-            name = "lua config script";
-            dag = cfg.luaConfigRC;
-            inherit mapResult;
-          };
-        in
-          entryAnywhere luaConfig;
-
-        extraPluginConfigs = let
-          mapResult = result: (wrapLuaConfig {
-            luaConfig = concatLines (map mkLuarcSection result);
-          });
-
-          extraPluginsDag = mapAttrs (_: {
-            after,
-            setup,
-            ...
-          }:
-            entryAfter after setup)
-          cfg.extraPlugins;
-
-          pluginConfig = resolveDag {
+    extraPluginConfigs = resolveDag {
       name = "extra plugins config";
-            dag = extraPluginsDag;
-            inherit mapResult;
+      dag = mapAttrs (_: value: entryAfter value.after value.setup) cfg.extraPlugins;
+      mapResult = result: concatLines (map mkLuarcSection result);
     };
-        in
-          entryAfter ["luaScript"] pluginConfig;
 
-        # This is probably not the right way to set the config. I'm not sure how it should look like.
-        mappings = let
     maps = [
       nmap
       imap
@@ -189,12 +142,14 @@ in {
       icmap
       allmap
     ];
-          mapConfig = wrapLuaConfig {luaConfig = concatLines (map concatLines maps);};
-        in
-          entryAfter ["globalsScript"] mapConfig;
+    mappings = concatLines (map concatLines maps);
+  in {
+    vim = {
+      luaConfigRC = {
+        globalsScript = concatLines globalsScript;
       };
 
-      builtConfigRC = let
+      builtLuaConfigRC = let
         # Catch assertions and warnings
         # and throw for each failed assertion. If no assertions are found, show warnings.
         failedAssertions = map (x: x.message) (filter (x: !x.assertion) config.assertions);
@@ -203,14 +158,22 @@ in {
           then throw "\nFailed assertions:\n${concatMapStringsSep "\n" (x: "- ${x}") failedAssertions}"
           else showWarnings config.warnings;
 
-        mapResult = result: concatMapStringsSep "\n" mkVimrcSection result;
-        vimConfig = resolveDag {
-          name = "vim config script";
-          dag = cfg.configRC;
-          inherit mapResult;
+        luaConfig = resolveDag {
+          name = "lua config script";
+          dag = cfg.luaConfigRC;
+          mapResult = result:
+            concatLines [
+              cfg.luaConfigPre
+
+              (concatMapStringsSep "\n" mkLuarcSection result)
+              extraPluginConfigs
+              mappings
+
+              cfg.luaConfigPost
+            ];
         };
       in
-        baseSystemAssertWarn vimConfig;
+        baseSystemAssertWarn luaConfig;
     };
   };
 }

modules/wrapper/rc/options.nix

@@ -121,36 +121,15 @@ in {
         An attribute set containing global variable values
         for storing vim variables as early as possible. If
         populated, this soption will set vim variables in the
-        built configRC as the first item.
+        built luaConfigRC as the first item.
 
-        E.g. {foo = "bar"} will set `g:foo` to "bar" where
+        E.g. {foo = "bar"} will set `vim.g.foo` to "bar" where
         the type of `bar` in the resulting vimscript will be
         infered from the type of the value in the `{name = value}`
         pair.
       '';
     };
 
-    configRC = mkOption {
-      type = oneOf [(dagOf lines) str];
-      default = {};
-      description = ''
-        Contents of vimrc, either as a string or a DAG.
-
-        If this option is passed as a DAG, it will be resolved
-        according to the DAG resolution rules (e.g. entryBefore
-        or entryAfter) as per the **nvf** extended library.
-      '';
-
-      example = literalMD ''
-        ```vim
-        " Set the tab size to 4 spaces
-        set tabstop=4
-        set shiftwidth=4
-        set expandtab
-        ```
-      '';
-    };
-
     luaConfigPre = mkOption {
       type = str;
       default = ''
@@ -245,10 +224,10 @@ in {
       '';
     };
 
-    builtConfigRC = mkOption {
+    builtLuaConfigRC = mkOption {
       internal = true;
       type = lines;
-      description = "The built config for neovim after resolving the DAG";
+      description = "The built lua config for neovim after resolving the DAG";
     };
   };
 }