It no longer generates the compile_commands.json file automatically like it used to.

[EmersonEE]

It no longer automatically generates the compile_commands.json file like it used to. I've tried several methods but haven't been able to get it working.

[anurag3301]

Yes, there has been some changes in the plugin. You'll have to specify some stuff in the user configuration.

vim.g.pioConfig ={
  lsp = 'clangd',           -- value: clangd | ccls 
  clangd_source = 'ccls',    -- value: ccls | compiledb
  menu_key = '<leader>\\',  -- replace this menu key  to your convenience
  debug = false             -- enable debug messages
} 
local pok, platformio = pcall(require, 'platformio')
if pok then platformio.setup(vim.g.pioConfig) end

you need to set the lsp=clangd and the changd_sorce to either ccls or compiledb, check :help platformio-clangd_source for detailed explaination.

There is a new command :PioLSP which generates the config file, you can run it manually if you dont have the compile_commands.json. This command is also executed automatically when you use :Pioinit or :Piolib

[dhupee]

considering this plugin is in constant development and breaking changes are not just present but expected for every update, you might wanna add warning to the readme if i suggest

[anurag3301]

Yes, that seems to be needed. Should I add a warning on README or maybe have Breaking changes warning in plugin managers, and how do you even do that.

[dhupee]

ever test whether usage of git commit semantic can be detected by lazy/packer?

[EmersonEE]

"Thank you. The automatic generation failed, so I handled the configuration manually.

I have another question regarding project structure: My .h files inside the lib directory are not being detected. Is there a specific configuration required for PlatformIO/Neovim to properly index headers in the lib folder?"

[anurag3301]

It would be great if you tell little more about the automatic generation failing, are you seeing some errors.

And ideally you put your .h files in the include directory. The directory structure of lib is bit different, ill check it out.

I've got this problem recently and I have to say that this is more of a downgrade than an upgrade. It's harder to use now and requires more setup than before plus it breaks much easier having more moving parts.

Unfortunately, I need a stable working env so I am ditching this for vscode plugin...even tho I despise vscode. Let me know if reach stability + ease of use or at the very least revert the latest changes.

[anurag3301]

Hey @Andynopol, yes the setup process has changed and lsp changes due to complains about clangd specially with ESPs. That said, I acknowledge that some of these changes may have introduced unnecessary complexity, and thats on me. I'm still relatively new to maintaining a plugin at this scale, and there may have been some bad design decisions.
I am thinking to remove the LazyLoad conditional option from the general setup as its making people more confused. Its suppose to be optional.
Saying that if you want absolute stability then "works always" nature can only be found on VS Code with first party support. This plugin was just to enable some support on Neovim, But I'll try to make things more stable and standard now.

If you have a general out of the box config(i place it in plugins and it works) with additional mason plugins if needed, I am willing to try, but right now it's not even registering that it's inside a pio project.

The commands work. The lsp is just now there... I am using your readme config so...i don't know what to tell you.

I went back to this because vscode is horrific and I ended up making it work similar to vscode but there is a problem.

Here is the edited plugin:

eturn {
  {
    "anurag3301/nvim-platformio.lua",

    dependencies = {
      "akinsho/toggleterm.nvim",
      "nvim-telescope/telescope.nvim",
      "nvim-telescope/telescope-ui-select.nvim",
      "nvim-lua/plenary.nvim",
      "folke/which-key.nvim",
      "nvim-treesitter/nvim-treesitter",
    },

    ft = { "c", "cpp", "h", "hpp" },
    cmd = {
      "Pioinit",
      "Piorun",
      "Piocmdh",
      "Piocmdf",
      "Piolib",
      "Piomon",
      "Piodebug",
      "Piodb",
      "PioLSP",
    },

    config = function()
      vim.g.pioConfig = {
        lsp = "clangd", -- or "ccls"
        clangd_source = "compiledb",
        menu_key = "<leader>\\",
        debug = false,
      }

      local ok, platformio = pcall(require, "platformio")
      if not ok then
        vim.notify("Failed to load PlatformIO plugin", vim.log.levels.ERROR)
        return
      end

      platformio.setup(vim.g.pioConfig)

      -- Removes host flags
      local function sanitize_compile_commands()
        local fname = vim.fn.getcwd() .. "/compile_commands.json"
        if vim.fn.filereadable(fname) ~= 1 then
          return
        end

        local content = vim.fn.readfile(fname)
        for i, line in ipairs(content) do
          -- remove unsupported ESP32 flags
          line = line:gsub("%-mlongcalls", "")
          line = line:gsub("%-fno%-tree%-switch%-conversion", "")
          line = line:gsub("%-mlong%-calls", "")
          line = line:gsub("%-fstrict%-volatile%-bitfields", "")
          content[i] = line
        end
        vim.fn.writefile(content, fname)
      end

      local function get_current_env()
        local fname = vim.fn.getcwd() .. "/platformio.ini"
        if vim.fn.filereadable(fname) ~= 1 then
          return nil
        end
        local lines = vim.fn.readfile(fname)
        for _, line in ipairs(lines) do
          local env = line:match("%[env:(.+)%]")
          if env then
            return env
          end
        end
        return nil
      end

      -- Function to generate compile_commands.json unconditionally if platformio.ini exists
      local function generate_compiler()
        local env = get_current_env()
        if not env then
          vim.notify("No PlatformIO environment found!", vim.log.levels.ERROR)
          return
        end
        vim.notify("Generating compile_commands.json for PlatformIO", vim.log.levels.INFO)
        local target = vim.g.pioConfig.lsp == "clangd" and "compiledb" or "ccls"
        local cmd = { "pio", "run", "-e", env, "-t", target }
        vim.fn.system(cmd)
        if vim.g.pioConfig.lsp == "clangd" then
          sanitize_compile_commands()
        end
      end

      -- Auto-generate compile_commands.json and attach LSP on opening C/C++ files
      vim.api.nvim_create_autocmd("BufReadPost", {
        pattern = { "*.c", "*.cpp", "*.h", "*.hpp" },
        callback = function()
          generate_compiler()
          vim.cmd("LspRestart")
        end,
      })

      -- Manual fallback command
      vim.api.nvim_create_user_command("PioLSP", function()
        generate_compiler()
        vim.cmd("LspRestart")
      end, { desc = "Generate compile_commands.json and attach PlatformIO LSP" })

      -- Auto-generate file for compiler. Works with PioLSP too. Just remove this if you don't like it.
      if vim.fn.filereadable(vim.fn.getcwd() .. "/platformio.ini") == 1 then
        vim.defer_fn(function()
          generate_compiler()
          vim.cmd("LspRestart")
        end, 100)
      end
    end,
  },
}

The problem that I encounter is that it does not this error:

Diagnostics:
1. Unknown argument '-mlongcalls'; did you mean '-mlong-calls'? [drv_unknown_argument_with_suggestion]
2. Unknown argument: '-fstrict-volatile-bitfields' [drv_unknown_argument]
3. Unknown argument: '-fno-tree-switch-conversion' [drv_unknown_argument]
4. Unsupported option '-mlong-calls' for target 'x86_64-unknown-linux-gnu' [drv_unsupported_opt_for_target]
5. In included file: 'machine/endian.h' file not found [pp_file_not_found]

This happens at the first line of my main.cpp regardless if what is in there. Why does it look for machiene/endian.h?

The sanitize_compile_commands is there to remove all but the 5th error. If you find a better solution for this, please show me.

I am on Omarchy so there might be some difference here from a clasic nvim(lazy vim) installation.

I hope to hear from you soon.

[anurag3301]

Uh this. This is again .clangd being annoying. This is exacly the issue which made me give multiple options. These are diagnostic errors being generated by clangd, I assume you are using ESP. Try the clangd_source to ccls. It tries to generate a clean compile_commands.json file includes only include path and defines. The pio run -t compiledb generates pretty ugly compile_commands.json which is good for compilation but pretty bad for clangd. The reason you dont see such erroes in vscode is it just doesnt do this depth of diagnostics.

vim.g.pioConfig = {
        lsp = "clangd", -- or "ccls"
        clangd_source = "ccls",
        menu_key = "<leader>\\",
        debug = false,
      }

      local ok, platformio = pcall(require, "platformio")
      if not ok then
        vim.notify("Failed to load PlatformIO plugin", vim.log.levels.ERROR)
        return
      end

If you still want to use compiledb then you'll have to create .clangd which supress such errors.

CompileFlags:
  Remove: 
    - -mlongcalls
    - -mlong-calls
    - -fstrict-volatile-bitfields
    - -fno-tree-switch-conversion

  Add: 
    - --target=arm-none-eabi
    - -Wno-unknown-warning-option
    - -Wno-unknown-attributes

Diagnostics:
  Suppress:
    - drv_unknown_argument
    - drv_unsupported_opt_for_target
    - pp_file_not_found

ClangTidy:
  Add: []
  Remove: ['*']

I changed it to ccls and I got the same result. I installed ccls made no difference. I looked into Mason and try to find it and nothing was there. It simply refuses to work...

return {
  {
    "anurag3301/nvim-platformio.lua",

    dependencies = {
      "akinsho/toggleterm.nvim",
      "nvim-telescope/telescope.nvim",
      "nvim-telescope/telescope-ui-select.nvim",
      "nvim-lua/plenary.nvim",
      "folke/which-key.nvim",
      "nvim-treesitter/nvim-treesitter",
    },

    ft = { "c", "cpp", "h", "hpp" },
    cmd = {
      "Pioinit",
      "Piorun",
      "Piocmdh",
      "Piocmdf",
      "Piolib",
      "Piomon",
      "Piodebug",
      "Piodb",
      "PioLSP",
    },

    config = function()
      vim.g.pioConfig = {
        lsp = "clangd", -- or "ccls"
        clangd_source = "ccls",
        menu_key = "<leader>\\",
        debug = false,
      }

      local ok, platformio = pcall(require, "platformio")
      if not ok then
        vim.notify("Failed to load PlatformIO plugin", vim.log.levels.ERROR)
        return
      end

      platformio.setup(vim.g.pioConfig)

      -- Removes host flags
      local function get_current_env()
        local fname = vim.fn.getcwd() .. "/platformio.ini"
        if vim.fn.filereadable(fname) ~= 1 then
          return nil
        end
        local lines = vim.fn.readfile(fname)
        for _, line in ipairs(lines) do
          local env = line:match("%[env:(.+)%]")
          if env then
            return env
          end
        end
        return nil
      end

      -- Function to generate compile_commands.json unconditionally if platformio.ini exists
      local function generate_compiler()
        local env = get_current_env()
        if not env then
          vim.notify("No PlatformIO environment found!", vim.log.levels.ERROR)
          return
        end
        vim.notify("Generating compile_commands.json for PlatformIO", vim.log.levels.INFO)
        local target = vim.g.pioConfig.lsp == "clangd" and "compiledb" or "compiledb"
        local cmd = { "pio", "run", "-e", env, "-t", target }
        vim.fn.system(cmd)
      end

      -- Auto-generate compile_commands.json and attach LSP on opening C/C++ files
      vim.api.nvim_create_autocmd("BufReadPost", {
        pattern = { "*.c", "*.cpp", "*.h", "*.hpp" },
        callback = function()
          generate_compiler()
          vim.cmd("LspRestart")
        end,
      })

      -- Manual fallback command
      vim.api.nvim_create_user_command("PioLSP", function()
        generate_compiler()
        vim.cmd("LspRestart")
      end, { desc = "Generate compile_commands.json and attach PlatformIO LSP" })

      -- Auto-generate file for compiler. Works with PioLSP too. Just remove this if you don't like it.
      if vim.fn.filereadable(vim.fn.getcwd() .. "/platformio.ini") == 1 then
        vim.defer_fn(function()
          generate_compiler()
          vim.cmd("LspRestart")
        end, 100)
      end
    end,
  },
}

Shouldn't the plugin generate a .ccls file in stead of compile_commands.json?

I made something like this:

return {
  {
    "anurag3301/nvim-platformio.lua",

    dependencies = {
      "akinsho/toggleterm.nvim",
      "nvim-telescope/telescope.nvim",
      "nvim-telescope/telescope-ui-select.nvim",
      "nvim-lua/plenary.nvim",
      "folke/which-key.nvim",
      "nvim-treesitter/nvim-treesitter",
    },

    ft = { "c", "cpp", "h", "hpp" },
    cmd = {
      "Pioinit",
      "Piorun",
      "Piocmdh",
      "Piocmdf",
      "Piolib",
      "Piomon",
      "Piodebug",
      "Piodb",
      "PioLSP",
    },

    config = function()
      vim.g.pioConfig = {
        lsp = "clangd", -- or "ccls"
        clangd_source = "compiledb",
        menu_key = "<leader>\\",
        debug = false,
      }

      local ok, platformio = pcall(require, "platformio")
      if not ok then
        vim.notify("Failed to load PlatformIO plugin", vim.log.levels.ERROR)
        return
      end

      platformio.setup(vim.g.pioConfig)

      -- Get all environments from platformio.ini
      local function get_envs()
        local fname = vim.fn.getcwd() .. "/platformio.ini"
        if vim.fn.filereadable(fname) ~= 1 then return {} end
        local envs = {}
        for _, line in ipairs(vim.fn.readfile(fname)) do
          local env = line:match("%[env:(.+)%]")
          if env then table.insert(envs, env) end
        end
        return envs
      end

      -- Clean unwanted flags from compile_commands.json
      local function clean_compile_commands()
        local fname = vim.fn.getcwd() .. "/compile_commands.json"
        if vim.fn.filereadable(fname) ~= 1 then return end

        local f = io.open(fname, "r")
        local data = f:read("*a")
        f:close()

        local ok, json = pcall(require, "dkjson")
        if not ok then return end
        local arr, _, err = json.decode(data)
        if err then
          vim.notify("Failed to parse compile_commands.json: " .. err, vim.log.levels.ERROR)
          return
        end

        local remove_flags = {
          "-mlongcalls",
          "-mlong-calls",
          "-fstrict-volatile-bitfields",
          "-fno-tree-switch-conversion",
        }

        for _, entry in ipairs(arr) do
          if entry.arguments then
            entry.arguments = vim.tbl_filter(function(a)
              for _, flag in ipairs(remove_flags) do
                if a == flag then return false end
              end
              return true
            end, entry.arguments)
          end
        end

        f = io.open(fname, "w")
        f:write(json.encode(arr, { indent = true }))
        f:close()
      end

      -- Optional: generate minimal .clangd
      local function generate_clangd_file()
        local f = io.open(".clangd", "w")
        if not f then return end
        f:write("CompileFlags:\n")
        f:write("  Remove:\n")
        f:write("    - -mlongcalls\n")
        f:write("    - -mlong-calls\n")
        f:write("    - -fstrict-volatile-bitfields\n")
        f:write("    - -fno-tree-switch-conversion\n")
        f:write("Diagnostics:\n")
        f:write("  Suppress:\n")
        f:write("    - drv_unknown_argument\n")
        f:write("    - drv_unsupported_opt_for_target\n")
        f:write("    - pp_file_not_found\n")
        f:close()
      end

      -- Generate compile_commands.json for all environments
      local function generate_compiler()
        local envs = get_envs()
        if #envs == 0 then
          vim.notify("No PlatformIO environments found!", vim.log.levels.ERROR)
          return
        end

        for _, env in ipairs(envs) do
          vim.notify("Generating compile_commands.json for env: " .. env, vim.log.levels.INFO)
          local cmd = { "pio", "run", "-e", env, "-t", "compiledb" }
          vim.fn.system(cmd)
          clean_compile_commands()
        end

        generate_clangd_file()
        vim.cmd("LspRestart")
      end

      -- Auto-generate compile_commands.json and attach LSP on opening C/C++ files
      vim.api.nvim_create_autocmd("BufReadPost", {
        pattern = { "*.c", "*.cpp", "*.h", "*.hpp" },
        callback = generate_compiler,
      })

      -- Manual fallback command
      vim.api.nvim_create_user_command("PioLSP", generate_compiler, {
        desc = "Generate compile_commands.json, .clangd, and attach PlatformIO LSP",
      })

      -- Auto-generate immediately if platformio.ini exists
      if vim.fn.filereadable(vim.fn.getcwd() .. "/platformio.ini") == 1 then
        vim.defer_fn(generate_compiler, 100)
      end
    end,
  },
}

I have no clue if it will work for multiple boards, but for now looks good.

Is this a dead repo?