Could not create parser dir. (LazyVim)

[MartinElvar]

I'm trying to enabled some extras from lazy, but I'm getting the following error when i boot up nvim.
Not too sure if I actually placed the imports correctly.

Error detected while processing User Autocommands for "VeryLazy": Could not create parser dir ' /nix/store/7494c5jfzw1swrr57d8g19c02ccq0cl6-vim-pack-dir/pack/myNeovimPackages/start/nvim-treesit ter/parser ': Vim:E739: Cannot create directory /nix/store/7494c5jfzw1swrr57d8g19c02ccq0cl6-vim-pack-dir/pack/myNeovimPackages /start/nvim-treesitter/parser: read-only file system

My init

-- NOTE: this just gives nixCats global command a default value
-- so that it doesnt throw an error if you didnt install via nix.
-- usage of both this setup and the nixCats command is optional,
-- but it is very useful for passing info from nix to lua so you will likely use it at least once.
require("nixCatsUtils").setup({
	non_nix_value = true,
})

-- NOTE: You might want to move the lazy-lock.json file
local function getlockfilepath()
	if require("nixCatsUtils").isNixCats and type(nixCats.settings.unwrappedCfgPath) == "string" then
		return nixCats.settings.unwrappedCfgPath .. "/lazy-lock.json"
	else
		return vim.fn.stdpath("config") .. "/lazy-lock.json"
	end
end
local lazyOptions = {
	lockfile = getlockfilepath(),
}

-- NOTE: this the lazy wrapper. Use it like require('lazy').setup() but with an extra
-- argument, the path to lazy.nvim as downloaded by nix, or nil, before the normal arguments.
require("nixCatsUtils.lazyCat").setup(nixCats.pawsible({ "allPlugins", "start", "lazy.nvim" }), {
	{ "LazyVim/LazyVim", import = "lazyvim.plugins" },
	-- disable mason.nvim while using nix
	-- precompiled binaries do not agree with nixos, and we can just make nix install this stuff for us.
	{ "williamboman/mason-lspconfig.nvim", enabled = require("nixCatsUtils").lazyAdd(true, false) },
	{ "williamboman/mason.nvim", enabled = require("nixCatsUtils").lazyAdd(true, false) },
	{
		"nvim-treesitter/nvim-treesitter",
		build = require("nixCatsUtils").lazyAdd(":TSUpdate"),
		opts_extend = require("nixCatsUtils").lazyAdd(nil, false),
		opts = {
			-- nix already ensured they were installed, and we would need to change the parser_install_dir if we wanted to use it instead.
			-- so we just disable install and do it via nix.
			ensure_installed = require("nixCatsUtils").lazyAdd(
				{ "bash", "c", "diff", "html", "lua", "luadoc", "markdown", "vim", "vimdoc" },
				false
			),
			auto_install = require("nixCatsUtils").lazyAdd(true, false),
		},
	},
	{
		"folke/lazydev.nvim",
		opts = {
			library = {
				{ path = (nixCats.nixCatsPath or "") .. "/lua", words = { "nixCats" } },
			},
		},
	},
	{ import = "lazyvim.plugins.extras.lang.git" },
	{ import = "lazyvim.plugins.extras.lang.json" },
	{ import = "lazyvim.plugins.extras.lang.markdown" },
	{ import = "lazyvim.plugins.extras.lang.nix" },
	{ import = "lazyvim.plugins.extras.lang.elixir" },
	{ import = "lazyvim.plugins.extras.lang.tailwind" },
	{ import = "lazyvim.plugins.extras.coding.mini-surround" },

	-- import/override with your plugins
	{ import = "plugins" },
}, lazyOptions)

-- require("lspconfig").elixirls.setup({
-- 	cmd = { "elixir-ls" },
-- })

[BirdeeHub]

Hmm it shouldn't be trying to create one at all, you have auto_install off and are installing them through nix probably. I'll take a look at this somewhat soon. It would be an issue with the lazyvim template though, the ones that don't use lazy.nvim don't have such issues.

[MartinElvar]

I'm trying to pinpoint it. It yields me an error if I enabled one of these 3 plugins.

-- { import = "lazyvim.plugins.extras.lang.git" },
-- { import = "lazyvim.plugins.extras.lang.json" },
-- { import = "lazyvim.plugins.extras.lang.nix" },

This is my flake.

# Copyright (c) 2023 BirdeeHub
# Licensed under the MIT license
{
  description = "A Lua-natic's neovim flake, with extra cats! nixCats!";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
    nixCats.url = "github:BirdeeHub/nixCats-nvim";

    # neovim-nightly-overlay = {
    #   url = "github:nix-community/neovim-nightly-overlay";
    # };

    # see :help nixCats.flake.inputs
    # If you want your plugin to be loaded by the standard overlay,
    # i.e. if it wasnt on nixpkgs, but doesnt have an extra build step.
    # Then you should name it "plugins-something"
    # If you wish to define a custom build step not handled by nixpkgs,
    # then you should name it in a different format, and deal with that in the
    # overlay defined for custom builds in the overlays directory.
    # for specific tags, branches and commits, see:
    # https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake.html#examples

  };

  # see :help nixCats.flake.outputs
  outputs =
    {
      self,
      nixpkgs,
      nixCats,
      ...
    }@inputs:
    let
      inherit (nixCats) utils;
      luaPath = "${./.}";
      forEachSystem = utils.eachSystem nixpkgs.lib.platforms.all;
      # the following extra_pkg_config contains any values
      # which you want to pass to the config set of nixpkgs
      # import nixpkgs { config = extra_pkg_config; inherit system; }
      # will not apply to module imports
      # as that will have your system values
      extra_pkg_config = {
        # allowUnfree = true;
      };
      # management of the system variable is one of the harder parts of using flakes.

      # so I have done it here in an interesting way to keep it out of the way.
      # It gets resolved within the builder itself, and then passed to your
      # categoryDefinitions and packageDefinitions.

      # this allows you to use ${pkgs.system} whenever you want in those sections
      # without fear.

      dependencyOverlays = # (import ./overlays inputs) ++
        [
          # This overlay grabs all the inputs named in the format
          # `plugins-<pluginName>`
          # Once we add this overlay to our nixpkgs, we are able to
          # use `pkgs.neovimPlugins`, which is a set of our plugins.
          (utils.standardPluginOverlay inputs)
          # add any other flake overlays here.

          # when other people mess up their overlays by wrapping them with system,
          # you may instead call this function on their overlay.
          # it will check if it has the system in the set, and if so return the desired overlay
          # (utils.fixSystemizedOverlay inputs.codeium.overlays
          #   (system: inputs.codeium.overlays.${system}.default)
          # )
        ];

      # see :help nixCats.flake.outputs.categories
      # and
      # :help nixCats.flake.outputs.categoryDefinitions.scheme
      categoryDefinitions =
        {
          pkgs,
          settings,
          categories,
          extra,
          name,
          mkPlugin,
          ...
        }@packageDef:
        {
          # to define and use a new category, simply add a new list to a set here,
          # and later, you will include categoryname = true; in the set you
          # provide when you build the package using this builder function.
          # see :help nixCats.flake.outputs.packageDefinitions for info on that section.

          # lspsAndRuntimeDeps:
          # this section is for dependencies that should be available
          # at RUN TIME for plugins. Will be available to PATH within neovim terminal
          # this includes LSPs
          lspsAndRuntimeDeps = with pkgs; {
            general = [
              universal-ctags
              curl
              # NOTE:
              # lazygit
              # Apparently lazygit when launched via snacks cant create its own config file
              # but we can add one from nix!
              (pkgs.writeShellScriptBin "lazygit" ''
                exec ${pkgs.lazygit}/bin/lazygit --use-config-file ${pkgs.writeText "lazygit_config.yml" ""} "$@"
              '')
              ripgrep
              fd
              stdenv.cc.cc
              lua-language-server
              beamMinimal28Packages.elixir-ls
              nil # Nix LS
              marksman # Markdown LS
              vscode-langservers-extracted # JSON LS

              stylua
            ];
          };

          # NOTE: lazy doesnt care if these are in startupPlugins or optionalPlugins
          # also you dont have to download everything via nix if you dont want.
          # but you have the option, and that is demonstrated here.
          startupPlugins = with pkgs.vimPlugins; {
            general = [
              # LazyVim
              lazy-nvim
              LazyVim
              bufferline-nvim
              lazydev-nvim
              conform-nvim
              flash-nvim
              friendly-snippets
              gitsigns-nvim
              grug-far-nvim
              noice-nvim
              lualine-nvim
              nui-nvim
              nvim-lint
              nvim-lspconfig
              nvim-treesitter-textobjects
              nvim-ts-autotag
              ts-comments-nvim
              blink-cmp
              nvim-web-devicons
              persistence-nvim
              plenary-nvim
              telescope-fzf-native-nvim
              telescope-nvim
              todo-comments-nvim
              tokyonight-nvim
              trouble-nvim
              vim-illuminate
              vim-startuptime
              which-key-nvim
              snacks-nvim
              nvim-treesitter-textobjects
              nvim-treesitter.withAllGrammars
              # This is for if you only want some of the grammars
              # (nvim-treesitter.withPlugins (
              #   plugins: with plugins; [
              #     nix
              #     lua
              #   ]
              # ))

              # sometimes you have to fix some names
              {
                plugin = catppuccin-nvim;
                name = "catppuccin";
              }
              {
                plugin = mini-ai;
                name = "mini.ai";
              }
              {
                plugin = mini-icons;
                name = "mini.icons";
              }
              {
                plugin = mini-pairs;
                name = "mini.pairs";
              }
              # you could do this within the lazy spec instead if you wanted
              # and get the new names from `:NixCats pawsible` debug command
            ];
          };

          # not loaded automatically at startup.
          # use with packadd and an autocommand in config to achieve lazy loading
          # NOTE: this template is using lazy.nvim so, which list you put them in is irrelevant.
          # startupPlugins or optionalPlugins, it doesnt matter, lazy.nvim does the loading.
          # I just put them all in startupPlugins. I could have put them all in here instead.
          optionalPlugins = { };

          # shared libraries to be added to LD_LIBRARY_PATH
          # variable available to nvim runtime
          sharedLibraries = {
            general = with pkgs; [
              # libgit2
            ];
          };

          # environmentVariables:
          # this section is for environmentVariables that should be available
          # at RUN TIME for plugins. Will be available to path within neovim terminal
          environmentVariables = {
            test = {
              CATTESTVAR = "It worked!";
            };
          };

          # If you know what these are, you can provide custom ones by category here.
          # If you dont, check this link out:
          # https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/setup-hooks/make-wrapper.sh
          extraWrapperArgs = {
            test = [
              ''--set CATTESTVAR2 "It worked again!"''
            ];
          };

          # lists of the functions you would have passed to
          # python.withPackages or lua.withPackages

          # get the path to this python environment
          # in your lua config via
          # vim.g.python3_host_prog
          # or run from nvim terminal via :!<packagename>-python3
          python3.libraries = {
            test = [ (_: [ ]) ];
          };
          # populates $LUA_PATH and $LUA_CPATH
          extraLuaPackages = {
            test = [ (_: [ ]) ];
          };
        };

      # And then build a package with specific categories from above here:
      # All categories you wish to include must be marked true,
      # but false may be omitted.
      # This entire set is also passed to nixCats for querying within the lua.

      # see :help nixCats.flake.outputs.packageDefinitions
      packageDefinitions = {
        # These are the names of your packages
        # you can include as many as you wish.
        nvim =
          {
            pkgs,
            name,
            mkPlugin,
            ...
          }:
          {
            # they contain a settings set defined above
            # see :help nixCats.flake.outputs.settings
            settings = {
              suffix-path = true;
              suffix-LD = true;
              wrapRc = true;
              # IMPORTANT:
              # your alias may not conflict with your other packages.
              # aliases = [ "vim" ];
              # neovim-unwrapped = inputs.neovim-nightly-overlay.packages.${pkgs.system}.neovim;
              hosts.python3.enable = true;
              hosts.node.enable = true;
            };
            # and a set of categories that you want
            # (and other information to pass to lua)
            categories = {
              general = true;
              test = false;
            };
            extra = { };
          };
        # an extra test package with normal lua reload for fast edits
        # nix doesnt provide the config in this package, allowing you free reign to edit it.
        # then you can swap back to the normal pure package when done.
        testnvim =
          { pkgs, mkPlugin, ... }:
          {
            settings = {
              suffix-path = true;
              suffix-LD = true;
              wrapRc = false;
              unwrappedCfgPath = utils.mkLuaInline "os.getenv('HOME') .. '/some/path/to/your/config'";
            };
            categories = {
              general = true;
              test = false;
            };
            extra = { };
          };
      };
      # In this section, the main thing you will need to do is change the default package name
      # to the name of the packageDefinitions entry you wish to use as the default.
      defaultPackageName = "nvim";
    in

    # see :help nixCats.flake.outputs.exports
    forEachSystem (
      system:
      let
        # the builder function that makes it all work
        nixCatsBuilder = utils.baseBuilder luaPath {
          inherit
            nixpkgs
            system
            dependencyOverlays
            extra_pkg_config
            ;
        } categoryDefinitions packageDefinitions;
        defaultPackage = nixCatsBuilder defaultPackageName;
        # this is just for using utils such as pkgs.mkShell
        # The one used to build neovim is resolved inside the builder
        # and is passed to our categoryDefinitions and packageDefinitions
        pkgs = import nixpkgs { inherit system; };
      in
      {
        # these outputs will be wrapped with ${system} by utils.eachSystem

        # this will make a package out of each of the packageDefinitions defined above
        # and set the default package to the one passed in here.
        packages = utils.mkAllWithDefault defaultPackage;

        # choose your package for devShell
        # and add whatever else you want in it.
        devShells = {
          default = pkgs.mkShell {
            name = defaultPackageName;
            packages = [ defaultPackage ];
            inputsFrom = [ ];
            shellHook = '''';
          };
        };

      }
    )
    // (
      let
        # we also export a nixos module to allow reconfiguration from configuration.nix
        nixosModule = utils.mkNixosModules {
          moduleNamespace = [ defaultPackageName ];
          inherit
            defaultPackageName
            dependencyOverlays
            luaPath
            categoryDefinitions
            packageDefinitions
            extra_pkg_config
            nixpkgs
            ;
        };
        # and the same for home manager
        homeModule = utils.mkHomeModules {
          moduleNamespace = [ defaultPackageName ];
          inherit
            defaultPackageName
            dependencyOverlays
            luaPath
            categoryDefinitions
            packageDefinitions
            extra_pkg_config
            nixpkgs
            ;
        };
      in
      {

        # these outputs will be NOT wrapped with ${system}

        # this will make an overlay out of each of the packageDefinitions defined above
        # and set the default overlay to the one named here.
        overlays = utils.makeOverlays luaPath {
          inherit nixpkgs dependencyOverlays extra_pkg_config;
        } categoryDefinitions packageDefinitions defaultPackageName;

        nixosModules.default = nixosModule;
        homeModules.default = homeModule;

        inherit utils nixosModule homeModule;
        inherit (utils) templates;
      }
    );
}

[BirdeeHub]

Hmmmm

Well, you have all the grammars installed via nix already. The issue is that it is trying to install it again. Also, the default parser install dir is inside the plugin which is inside the store. What is weird though is that it isn't respecting our settings.

I have 3.5 ideas to help right now. Hopefully one or both of the first 2 solve the problem, if so there are some easy improvements I can make to the template. But if not, choose one of the other 2. Hopefully, this also explains what is going on.

1. (edit: apparently not this one)

I am curious, what happens when you do the following?

  -- List of parsers to ignore installing (or "all")
  ignore_install = { "all" },

or maybe just

  -- List of parsers to ignore installing (or "all")
  ignore_install = "all",

idk its not clear which from the nvim-treesitter docs, but this should prevent it from trying to install any itself?

The issue is that they are added via nix not treesitter, so they are just on the runtime path. So treesitter does not know that they are there, and { import = "lazyvim.plugins.extras.lang.json" }, adds ensure_installed = { "json5" }

2:

lazy.nvim merges specs. I think in order.

What happens if you move the

{ import = "lazyvim.plugins.extras.lang.git" },
{ import = "lazyvim.plugins.extras.lang.json" },
{ import = "lazyvim.plugins.extras.lang.nix" },

Up a few lines to be above nvim-treesitter? Then the settings you set in your nvim-treesitter spec should override any additions they may add.

3: If those don't work

By default, nvim-treesitter tries to install stuff into its own path. It is currently in the nix store.

https://github.com/nvim-treesitter/nvim-treesitter?tab=readme-ov-file#changing-the-parser-install-directory

You can change where it tries to install things to. Point it somewhere outside of the store.

Unfortunately this means some might get installed twice so I am hoping you can just do ignore_install = "all"

So, as an extra to that, if you wanted to avoid the 3 or so parsers being installed twice:

You could install pkgs.stdenv.cc via lspsAndRuntimeDeps

Then remove the withAllGrammars from nvim-treesitter.withAllGrammars and allow nvim-treesitter to manage all of them.

3.5:

sorta like 3 above, by default, nvim-treesitter tries to install stuff into its own path.

You can change this by downloading it by lazy.nvim instead, which will put it somewhere outside of the store.

If you do that, remove nvim-treesitter.withAllGrammars from your nix.

They will probably fail. So you will need to install pkgs.stdenv.cc via lspsAndRuntimeDeps

Then allow nvim-treesitter to manage them.

[MartinElvar]

Hi @BirdeeHub

Ignore install didn't work, i tried the different formats with no luck.
But moving the imports before treesitter did the trick 💯 🍾

Appreciate the top tier support, and the great read it gave me some insight of inner workings. :-)