Disable when in a comment?

[ianchesal]

I used to do this in nvim-cmp with some function logic on the enable option like this:

local context = require("cmp.config.context")
...stuff....
disabled = disabled or context.in_treesitter_capture("comment")
...stuff...
return not disabled

I'm trying to recreate this for blink but I can't seem to detect a comment. I've got this so far:

return {
  "saghen/blink.cmp",
  opts = {
    keymap = {
      preset = "default",
    },
    enabled = function()
      local node = vim.treesitter.get_node()
      local disabled = false
      disabled = disabled or (vim.tbl_contains({ "markdown" }, vim.bo.filetype))
      disabled = disabled or (vim.bo.buftype == "prompt")
      disabled = disabled or (node and string.find(node:type(), "comment"))
      return not disabled
    end,
  },
}

The:

node and string.find(node:type(), "comment")

doesn't seem to work correctly. And enabled doesn't seem to fire for every treesitter context change.

Is there a way to do this?

I'm using blink via LazyVim if that makes a difference.

[ianchesal]

Still struggling to make this happen. Based on this recipe I tried the following but I'm still seeing copilot and dynamic snippet options in the blink suggestions when I'm in a comment block in Ruby or Lua code:

return {
  "saghen/blink.cmp",
  opts = {
    enabled = function()
      local disabled = false
      local success, node = pcall(vim.treesitter.get_node)
      -- disabled = disabled or (vim.tbl_contains({ "markdown" }, vim.bo.filetype))
      disabled = disabled or (vim.bo.buftype == "prompt")
      disabled = disabled or (vim.fn.reg_recording() ~= "")
      disabled = disabled or (vim.fn.reg_executing() ~= "")
      disabled = disabled
        or (success and node ~= nil and vim.tbl_contains({ "comment", "line_comment", "block_comment" }, node:type()))

      return not disabled
    end,
  },
}

I'm using LazyVim if that matters. Everything is up-to-date.

My full configuration is here.

[bwlee13]

If you are in a lua comment and you start typing somewhere in the middle of the comment, does this end up working? I can get it working inside a comment, but not from the end of the comment because treesitter.get_node() has it as a table and not a comment or comment_content

[ianchesal]

Hmm. I haven't tried that. I'll give it an attempt. My testing has consisted of starting a comment on an empty line.

[martazvch]

Interested too

[bwlee13]

I DO NOT HAVE THE ANSWER...

return {
  {
    "saghen/blink.cmp",
    dependencies = { "rafamadriz/friendly-snippets" },
    version = "*",
    opts = {
      appearance = {
        use_nvim_cmp_as_default = true,
        nerd_font_variant = "mono",
      },
      keymap = {
        preset = "default",
        ["<C-j>"] = { "select_next", "fallback" },
        ["<C-k>"] = { "select_prev", "fallback" },
        ["<C-u>"] = { "scroll_documentation_up" },
        ["<C-d>"] = { "scroll_documentation_down" },
        ["<C-h>"] = { "hide" },
        ["<CR>"] = { "accept", "fallback" },
      },
      -- this is my test
      -- the following seems to be working
      sources = {
        default = function()
          local node = vim.treesitter.get_node()
          if
            node and vim.tbl_contains({ "comment", "line_comment", "comment_content", "block_comment" }, node:type())
          then
            return { "buffer" }
          else
            return {  "lsp", "path", "snippets", "buffer"  }
          end
        end,
      },

      completion = {
        ghost_text = { enabled = false },
      },
    },
    opts_extend = { "sources.default" },
  },
}

[bwlee13]

I'm thinking out loud here - what if we set a lua callback code to turn it off based on the line we're on by reading the line and looking for comment syntax? I was thinking about trying this today but it just seems overkill and obviously won't apply for multiline comments. I'm teetering between wanting to get it to work and not wanting to spend hours writing custom code for it haha! But I think a quick function to read the line, ask the lsp what language were on, then checking if this line is a comment.

Any thoughts?

[resistorsoftware]

To me it all boils down to Treesitter. I do not know enough about it, but fundamentally, it has the language grammar. So based on that, I cannot believe there is not a way to ask the TS the basic question, what am I inside of? I saw in a Lua file for example, that my node was inside an if statement (to paraphrase), so I am surprised we are not getting a you are inside a comment right now.

[bwlee13]

I know thats where this is tricky. The method I tried at least says "Hey treesitter, where is my cursor?" And it responds with "on a table" or something like that. It works when I'm actually INSIDE a comment, but not at the end of one. There surely is a method for "Hey treesitter, what type of line am i currently on? Is it a comment line??"
Maybe that's what we need to look for

[resistorsoftware]

Ya! I got that gist looking at the table function where you feed in a table with potential comments, and compare it to the current node. And if the node reports I am a comment of some sort, bingo. Return false for any kind of completion source. I want the same thing for a "String of text" too, since typing into a string likely needs zero completions. So this is super interesting. I know that recipe for No Completions Till Special Character is detected! business, but that seems awfully clunky compared to just asking treesitter, what is this? A comment, a string, a function, a statement, a whatever...

[bwlee13]

I was thinking the same thing about the "clunk" of it all

[DeidaraMC]

Seems to work good for me simply checking the spot 1 space to the left of the cursor!
You need to put this in the completion.menu.auto_show function

auto_show = function (ctx)
    local row, column = unpack(vim.api.nvim_win_get_cursor(0))
    local success, node = pcall(vim.treesitter.get_node, {
        pos = { row - 1, math.max(0, column - 1) },
        ignore_injections = false
    })
    local reject = { "comment", "line_comment", "block_comment", "string_start", "string_content", "string_end" }
    if success and node and vim.tbl_contains(reject, node:type()) then
        return false;
    end
    -- whatever other logic you want beyond this
    return true
end,

I've only tested this fully in Zig

[DeidaraMC]

I've also found that removing buffer from sources altogether resolves this as well
sources.default = { 'lsp', 'path', 'snippets' }
I can't imagine ever really needing to use the buffer based completions for anything

[resistorsoftware]

In plain english, what would a buffer based completion be? If I am working in a file, am I to assume the file is the buffer? So, would a buffer completion not be something along the lines of "Hey, I saw this method somewhere in this file before, therefore you might want to see it again, here, as a completion."

The Lingo of this has not been my strongpoint. So what is the buffer source anyway? I have not found an explanation in plain english for path either. I get LSP and Snippets as sources though... LSP would provide me with some expected built-ins whereas Snippets are custom to say a framework.

[DeidaraMC]

I believe the buffer completion just takes words you've already written and suggests them back to you.
So imagine if you're writing in a .txt file there's no lsp or snippets to aid you here, but there are words you've already typed which may or may not be important to you. The buffer completion will give you those.
I turn this off on any IDE I use since I generally only care about what the lsp thinks is important for me (or snippets)

[resistorsoftware]

That is what I thought. It does seem to be of very little utility to me then. The idea of removing buffer solutions may then be the ticket!

[resistorsoftware]

Unfortunately, even when I remove buffers as a source, snippets kick in at 2 characters and the treesitter problem with nodes still kicks and we get suggestions in a menu while adding a comment or a string. I am guessing the Tree Sitter parser is at fault, but fixing that is a huge task.

[jtackaberry]

I was migrating from AstroNvim v4 to v5 which, among other things, has replaced nvim-cmp with blink.nvim. With every other customization due to a replaced plugin that I had to reimplement, I'd never have imagined this would be the thing to do me in.

Despite various suggestions in this discussion, the only thing that actually worked for me was ripping the logic out of nvim-cmp and using that. nvim-cmp can also handle non-treesitter cases, but for my purposes I was fine with requiring TS.

-- Lifted from https://github.com/hrsh7th/nvim-cmp/blob/v0.0.2/lua/cmp/config/context.lua
function in_treesitter_capture(capture)
  local row, col = unpack(vim.api.nvim_win_get_cursor(0))
  if vim.api.nvim_get_mode().mode == 'i' then
    col = col - 1
  end

  local buf = vim.api.nvim_get_current_buf()
  local get_captures_at_pos = require('vim.treesitter').get_captures_at_pos

  local captures_at_cursor = vim.tbl_map(function(x)
    return x.capture
  end, get_captures_at_pos(buf, row - 1, col))

  if vim.tbl_isempty(captures_at_cursor) then
    return false
  elseif type(capture) == 'string' and vim.tbl_contains(captures_at_cursor, capture) then
    return true
  elseif type(capture) == 'table' then
    for _, v in ipairs(capture) do
      if vim.tbl_contains(captures_at_cursor, v) then
        return true
      end
    end
  end
  return false
end

return {
  "Saghen/blink.cmp",
  opts = {
    completion = {
      menu = {
        auto_show = function()
          return not in_treesitter_capture("comment") and not require("luasnip").expand_or_jumpable()
        end
      }
    }
  },
}

[becknik]

This is what I'm using in Neovim 0.11.2 to enable git commit & emoji cmp with blink in comments. This surely is a bit off-topic, but maybe it might provide some help.

I basically took the code from @DeidaraMC and added the {buffer} property:

function is_in_string_like_node()
  if vim.bo.buftype == "prompt" then
    return false
  elseif vim.tbl_contains({ 'gitcommit', 'markdown' }, vim.bo.filetype) then
    return true
  end

  local row, column = unpack(vim.api.nvim_win_get_cursor(0))
  local success, node = pcall(vim.treesitter.get_node, {
    bufnr = 0,
    pos = { row - 1, math.max(0, column - 1) } -- seems to be necessary...
  })

  -- `string_fragment` is a node type reported in react files, so I've added it
  local reject = { "comment", "line_comment", "block_comment", "string_start", "string_fragment", "string_content", "string_end" }
  return (success and node and vim.tbl_contains(reject, node:type()))
end

I'm using this function reference in the table path providers.(git|emoji).should_show_items