feat: use nvim_echo for emitting errors and notifs (#1523)

* refactor(validate): Use `nvim_echo` for emitting config errors

Ref: #973

* chore: Fixed spacing issue

* chore: Fixed nested indentation

* chore: Stylua check pass

* fix(validate): Delayed config error emission for when `noice.nvim` is being used

* refactor(validate): Changed how message is handled for external message UIs

refactor(validate): Added `nvim-notify` to the external message UI
detection function

* refactor(fuzzy): Binary download related errors are now handled via a custom notification function

* chore(validate): Added title to notifications in config validator

* refactor(validate): Config validator now uses the same function for notification as the fuzzy downloader

* feat: move to utils, adjust error wording, correctly handle failure

* chore: remove `vim.api.nvim_echo` check

* fix: misleading error message when not on git tag with outdated prebuilt binaries

Closes #1628

* docs: update version reference to recommend `1.*`

---------

Co-authored-by: Liam Dyer <[email protected]>

Author: OXY2DEV

doc/configuration/fuzzy.md

@@ -29,7 +29,7 @@ If possible, it's highly recommended to use the Rust implementation of the fuzzy
 
 ### Prebuilt binaries (default on a release tag)
 
-By default, Blink will download a prebuilt binary from the latest release, when you're on a release tag (via `version = '*'` on `lazy.nvim` for example). If you're not on a release tag, you may force a specific version via `fuzzy.prebuilt_binaries.force_version`. See [the latest release](https://github.com/saghen/blink.cmp/releases/latest) for supported systems. See `prebuilt_binaries` section of the [reference configuration](./reference.md#fuzzy) for more options.
+By default, Blink will download a prebuilt binary from the latest release, when you're on a release tag (via `version = '1.*'` on `lazy.nvim` for example). If you're not on a release tag, you may force a specific version via `fuzzy.prebuilt_binaries.force_version`. See [the latest release](https://github.com/saghen/blink.cmp/releases/latest) for supported systems. See `prebuilt_binaries` section of the [reference configuration](./reference.md#fuzzy) for more options.
 
 You may instead install the prebuilt binaries manually by downloading the appropriate binary from the [latest release](https://github.com/saghen/blink.cmp/releases/latest) and placing it at `$data/lazy/blink.cmp/target/release/libblink_cmp_fuzzy.$ext`. Get the `$data` path via `:echo stdpath('data')`. Use `.so` for linux, `.dylib` for mac, and `.dll` for windows. If you're unsure whether you want `-musl` or `-gnu` for linux, you very likely want `-gnu`.
 

lua/blink/cmp/config/utils.lua

@@ -34,7 +34,23 @@ function utils.validate(path, tbl, source)
 
   -- check for erroneous fields
   for k, _ in pairs(source) do
-    if tbl[k] == nil then error(path .. '.' .. k .. ': unexpected field found in configuration') end
+    if tbl[k] == nil then
+      ---@type string[]
+      local path_parts = vim.split(path, '.', { plain = true })
+      local msg = {}
+
+      for _, part in ipairs(path_parts) do
+        table.insert(msg, { ' ' .. part .. ' ', 'DiagnosticVirtualTextInfo' })
+        table.insert(msg, { ' → ' })
+      end
+
+      --- Highlight the last segment in ERROR since that's
+      --- where the issue lies.
+      table.insert(msg, { ' ' .. k .. ' ', 'DiagnosticVirtualTextError' })
+      table.insert(msg, { ' Unexpected field in configuration!' })
+
+      require('blink.cmp.lib.utils').notify(msg)
+    end
   end
 end
 

lua/blink/cmp/fuzzy/download/init.lua

@@ -4,6 +4,7 @@ local async = require('blink.cmp.lib.async')
 local git = require('blink.cmp.fuzzy.download.git')
 local files = require('blink.cmp.fuzzy.download.files')
 local system = require('blink.cmp.fuzzy.download.system')
+local utils = require('blink.cmp.lib.utils')
 
 local download = {}
 
@@ -33,120 +34,131 @@ function download.ensure_downloaded(callback)
         if version.current.sha == version.git.sha or download_config.ignore_version_mismatch then return end
 
         -- out of date
-        vim.schedule(
-          function()
-            vim.notify(
-              '[blink.cmp]: Found an outdated version of the locally built fuzzy matching library',
-              vim.log.levels.WARN,
-              { title = 'blink.cmp' }
-            )
-          end
-        )
-
-        -- downloading enabled but not on a git tag, error
-        if download_config.download and target_git_tag == nil then
-          if target_git_tag == nil then
-            error(
-              "Found an outdated version of the fuzzy matching library, but can't download from github due to not being on a git tag."
-                .. '\n!! FOR DEVELOPERS !!, set `fuzzy.prebuilt_binaries.ignore_version_mismatch = true` in config.'
-                .. '\n!! FOR USERS !!, either run `cargo build --release` via your package manager, switch to a git tag, or set `fuzzy.prebuilt_binaries.force_version` in config.'
-                .. '\nSee the docs for more info.'
-            )
-          end
+        utils.notify({
+          { 'Found an ' },
+          { 'outdated version', 'DiagnosticWarn' },
+          { ' of the locally built ' },
+          { 'fuzzy matching library', 'DiagnosticInfo' },
+        })
 
         -- downloading is disabled, error
-        else
-          error(
-            'Found an outdated version of the fuzzy matching library, but downloading from github is disabled.'
-              .. '\n!! FOR DEVELOPERS !!, set `fuzzy.prebuilt_binaries.ignore_version_mismatch = true` in config.'
-              .. '\n!! FOR USERS !!, either run `cargo build --release` via your package manager, or set either `fuzzy.prebuilt_binaries.download = true` or `fuzzy.prebuilt_binaries.force_version` in config.'
-              .. '\nSee the docs for more info.'
-          )
+        if not download_config.download then
+          utils.notify({
+            { "Couldn't update fuzzy matching library due to github downloads being disabled." },
+            { ' Try setting ' },
+            { " build = 'cargo build --release' ", 'DiagnosticVirtualTextInfo' },
+            { ' in your lazy.nvim spec and re-installing (requires Rust nightly), or enable ' },
+            { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+            { 'ignore_version_mismatch', 'DiagnosticWarn' },
+            { ' or set ' },
+            { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+            { 'force_version', 'DiagnosticWarn' },
+          })
+          return false
+
+        -- downloading enabled but not on a git tag, error
+        elseif target_git_tag == nil then
+          utils.notify({
+            { "Couldn't download the updated " },
+            { 'fuzzy matching library', 'DiagnosticInfo' },
+            { ' due to not being on a ' },
+            { 'git tag', 'DiagnosticInfo' },
+            { '. Try building from source via ' },
+            { " build = 'cargo build --release' ", 'DiagnosticVirtualTextInfo' },
+            { ' in your lazy.nvim spec and re-installing (requires Rust nightly), or switch to a ' },
+            { 'git tag', 'DiagnosticInfo' },
+            { ' via ' },
+            { " version = '1.*' ", 'DiagnosticVirtualTextInfo' },
+            { ' in your lazy.nvim spec. Or ignore this error by enabling ' },
+            { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+            { 'ignore_version_mismatch', 'DiagnosticWarn' },
+            { '. Or force a specific version via ' },
+            { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+            { 'force_version', 'DiagnosticWarn' },
+          })
+          return false
         end
       end
 
-      -- downloading disabled but not built locally
+      -- downloading disabled but not built locally, error
       if not download_config.download then
-        -- Fallback, just check if the shared rust library exists
-        vim.schedule(
-          function()
-            vim.notify('[blink.cmp]: No fuzzy matching library found', vim.log.levels.ERROR, { title = 'blink.cmp' })
-          end
-        )
-
-        error(
-          'No fuzzy matching library found, but downloading from github is disabled.'
-            .. '\nEither run `cargo build --release` via your package manager, or set `fuzzy.prebuilt_binaries.download = true` in config.'
-            .. '\nSee the docs for more info.'
-        )
+        utils.notify({
+          { 'No fuzzy matching library found!' },
+          { ' Try setting ' },
+          { " build = 'cargo build --release' ", 'DiagnosticVirtualTextInfo' },
+          { ' in your lazy.nvim spec and re-installing (requires Rust nightly), or enable ' },
+          { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+          { 'download', 'DiagnosticWarn' },
+        })
+        return false
       end
 
-      -- downloading enabled but not on a git tag
+      -- downloading enabled but not on a git tag, error
       if target_git_tag == nil then
-        vim.schedule(
-          function()
-            vim.notify('[blink.cmp]: No fuzzy matching library found', vim.log.levels.ERROR, { title = 'blink.cmp' })
-          end
-        )
-
-        error(
-          "No fuzzy matching library found, but can't download from github due to not being on a git tag and no `fuzzy.prebuilt_binaries.force_version` is set."
-            .. '\nEither run `cargo build --release` via your package manager, switch to a git tag, or set `fuzzy.prebuilt_binaries.force_version` in config.'
-            .. '\nSee the docs for more info.'
-        )
+        utils.notify({
+          { 'No fuzzy matching library found!' },
+          { ' Try building from source via ' },
+          { " build = 'cargo build --release' ", 'DiagnosticVirtualTextInfo' },
+          { ' in your lazy.nvim spec and re-installing (requires Rust nightly), or switch to a ' },
+          { 'git tag', 'DiagnosticInfo' },
+          { ' via ' },
+          { " version = '1.*' ", 'DiagnosticVirtualTextInfo' },
+          { ' in your lazy.nvim spec, or set ' },
+          { 'fuzzy.prebuilt_binaries.', 'DiagnosticInfo' },
+          { 'force_version', 'DiagnosticWarn' },
+        })
+        return false
       end
 
       -- already downloaded and the correct version, just verify the checksum, and re-download if checksum fails
       if version.current.tag == target_git_tag then
         return files.verify_checksum():catch(function(err)
-          vim.schedule(function()
-            vim.notify(err, vim.log.levels.WARN, { title = 'blink.cmp' })
-            vim.notify(
-              '[blink.cmp]: Pre-built binary failed checksum verification, re-downloading',
-              vim.log.levels.WARN,
-              { title = 'blink.cmp' }
-            )
-          end)
+          utils.notify({
+            { 'Pre-built binary checksum verification failed, ' },
+            { err, 'DiagnosticError' },
+          }, vim.log.levels.ERROR)
           return download.download(target_git_tag)
         end)
       end
 
       -- download as per usual
-      vim.schedule(
-        function() vim.notify('[blink.cmp]: Downloading pre-built binary', vim.log.levels.INFO, { title = 'blink.cmp' }) end
-      )
+      utils.notify({ { 'Downloading pre-built binary' } }, vim.log.levels.INFO)
       return download.download(target_git_tag)
     end)
-    :map(function()
+    :map(function(success)
+      if success == false then
+        -- fallback to lua implementation
+        if fuzzy_config.implementation == 'prefer_rust' then
+          callback(nil, 'lua')
+
+        -- fallback to lua implementation and emit warning
+        elseif fuzzy_config.implementation == 'prefer_rust_with_warning' then
+          utils.notify({
+            { 'Falling back to ' },
+            { 'Lua implementation', 'DiagnosticInfo' },
+            { ' due to error while downloading pre-built binary, set ' },
+            { 'fuzzy.', 'DiagnosticInfo' },
+            { 'implementation', 'DiagnosticWarn' },
+            { ' to ' },
+            { ' "prefer_rust" ', 'DiagnosticVirtualTextInfo' },
+            { ' or ' },
+            { ' "lua" ', 'DiagnosticVirtualTextInfo' },
+            { ' to disable this warning. See ' },
+            { ':messages', 'DiagnosticInfo' },
+            { ' for details.' },
+          })
+          callback(nil, 'lua')
+        else
+          callback('Failed to setup fuzzy matcher and rust implementation forced. See :messages for details')
+        end
+        return
+      end
+
       -- clear cached module first since we call it in the pcall above
       package.loaded['blink.cmp.fuzzy.rust'] = nil
-
       callback(nil, 'rust')
     end)
-    :catch(function(err)
-      -- fallback to lua implementation
-      if fuzzy_config.implementation == 'prefer_rust' then
-        callback(nil, 'lua')
-
-      -- fallback to lua implementation and emit warning
-      elseif fuzzy_config.implementation == 'prefer_rust_with_warning' then
-        vim.schedule(function()
-          vim.notify(
-            '[blink.cmp]: Falling back to Lua implementation due to error while downloading pre-built binary:\n' .. err,
-            vim.log.levels.WARN,
-            { title = 'blink.cmp' }
-          )
-          vim.notify(
-            "[blink.cmp]: Set `fuzzy.implementation = 'prefer_rust' | 'lua'` to suppress this warning.",
-            vim.log.levels.WARN,
-            { title = 'blink.cmp' }
-          )
-        end)
-        callback(nil, 'lua')
-      else
-        callback(err)
-      end
-    end)
+    :catch(callback)
 end
 
 function download.download(version)
@@ -163,9 +175,14 @@ end
 function download.from_github(tag)
   return system.get_triple():map(function(system_triple)
     if not system_triple then
-      return error(
-        'Your system is not supported by pre-built binaries. You must run cargo build --release via your package manager with rust nightly. See the README for more info.'
-      )
+      utils.notify({
+        { 'Your system is not supported by ' },
+        { ' pre-built binaries ', 'DiagnosticVirtualTextInfo' },
+        { '. Try building from source via ' },
+        { " build = 'cargo build --release' ", 'DiagnosticVirtualTextInfo' },
+        { ' in your lazy.nvim spec and re-installing (requires Rust nightly)' },
+      })
+      return
     end
 
     local base_url = 'https://github.com/saghen/blink.cmp/releases/download/' .. tag .. '/'

lua/blink/cmp/init.lua

@@ -20,7 +20,7 @@ function cmp.setup(opts)
   config.merge_with(opts)
 
   require('blink.cmp.fuzzy.download').ensure_downloaded(function(err, fuzzy_implementation)
-    if err then return vim.notify(err, vim.log.levels.ERROR) end
+    if err then error(err) end
     require('blink.cmp.fuzzy').set_implementation(fuzzy_implementation)
 
     -- setup highlights, keymap, completion, commands and signature help

lua/blink/cmp/lib/utils.lua

@@ -163,4 +163,42 @@ function utils.with_no_autocmds(cb)
   return result_or_err
 end
 
+---@type boolean Have we passed UIEnter?
+local _ui_entered = vim.v.vim_did_enter == 1 -- technically for VimEnter, but should be good enough for when we're lazy loaded
+---@type function[] List of notifications.
+local _notification_queue = {}
+
+--- Fancy notification wrapper.
+--- @param msg [string, string?][]
+--- @param lvl? number
+function utils.notify(msg, lvl)
+  local header_hl = 'DiagnosticVirtualTextWarn'
+  if lvl == vim.log.levels.ERROR then
+    header_hl = 'DiagnosticVirtualTextError'
+  elseif lvl == vim.log.levels.INFO then
+    header_hl = 'DiagnosticVirtualTextInfo'
+  end
+
+  table.insert(msg, 1, { ' blink.cmp ', header_hl })
+  table.insert(msg, 2, { ' ' })
+
+  if _ui_entered then
+    -- After UIEnter emit message immediately
+    vim.api.nvim_echo(msg, true, { err = true, verbose = false })
+  else
+    -- Queue notification for the UIEnter event.
+    table.insert(_notification_queue, function() vim.api.nvim_echo(msg, true, { verbose = false }) end)
+  end
+end
+
+vim.api.nvim_create_autocmd('UIEnter', {
+  callback = function()
+    _ui_entered = true
+
+    for _, fn in ipairs(_notification_queue) do
+      pcall(fn)
+    end
+  end,
+})
+
 return utils