Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

bug: recursion when settings up hydra? #811

Closed
4 tasks done
Ajaymamtora opened this issue Aug 2, 2024 · 10 comments · May be fixed by #884
Closed
4 tasks done

bug: recursion when settings up hydra? #811

Ajaymamtora opened this issue Aug 2, 2024 · 10 comments · May be fixed by #884
Labels
bug Something isn't working stale

Comments

@Ajaymamtora
Copy link

Ajaymamtora commented Aug 2, 2024 •
edited
Loading

Did you check docs and existing issues?

  • I have read all the which-key.nvim docs
  • I have updated the plugin to the latest version before submitting this issue
  • I have searched the existing issues of which-key.nvim
  • I have searched the existing issues of plugins related to this issue

Neovim version (nvim -v)

0.10 stable

Operating system/version

Macos 14.5

Describe the bug

Trying to replicate hydra with ;D but invoking it causes a loop?

Steps To Reproduce

Add a key which invokes hydra, where the sub actions start with the same as the hydra key. I dont see how I would do this otherwise?

Expected Behavior

The hydra popup opens and doesn't complain about recursion

Health

==============================================================================
which-key: require("which-key.health").check()

- OK Most of these checks are for informational purposes only.
  WARNINGS should be treated as a warning, and don't necessarily indicate a problem with your config.
  Please |DON't| report these warnings as an issue.

Checking your config ~
- WARNING |mini.icons| is not installed
- OK |nvim-web-devicons| is installed

Checking for issues with your mappings ~
- OK No issues reported

checking for overlapping keymaps ~
- WARNING In mode `n`, <<> overlaps with <<<>:
  - <<>: Indent left
- WARNING In mode `n`, <y> overlaps with <yq>, <ys>, <yss>, <yS>, <ySS>:
  - <y>: Yank text
  - <yq>:  Yank Macro
  - <ys>: Add a surrounding pair around a motion (normal mode)
  - <yss>: Add a surrounding pair around the current line (normal mode)
  - <yS>: Add a surrounding pair around a motion, on new lines (normal mode)
  - <ySS>: Add a surrounding pair around the current line, on new lines (normal mode)
- WARNING In mode `n`, <#> overlaps with <##>:
  - <#>: Search word and go previous
  - <##>:  Insert Macro Breakpoint.
- WARNING In mode `n`, <=> overlaps with <=P>, <=p>, <==>:
  - <=P>: YankyPutBeforeFilter
  - <=p>: YankyPutAfterFilter
- WARNING In mode `n`, <>> overlaps with <>>>:
  - <>>: Indent right
- WARNING In mode `n`, <;D> overlaps with <;D<M-8>>, <;D<M-2>>, <;D<M-1>>, <;D<M-0>>, <;D<M-9>>, <;D<C-C><C-C>X>, <;D<C-C><C-C>p>, <;D<C-C><C-C>f>, <;D<C-C><C-C>q>, <;D<C-C><C-C>g>, <;D<C-C><C-C>c>, <;D<C-C><C-C>x>, <;D<C-C><C-L>>, <;D<M-7>>, <;D<M-6>>, <;D<M-5>>, <;D<M-4>>, <;D<M-3>>:
  - <;D>: Breakpoint toggle
  - <;D<M-8>>: Close
  - <;D<M-2>>: Continue
  - <;D<M-1>>: Breakpoint toggle
  - <;D<M-0>>: Toggle repl
  - <;D<M-9>>: Restart
  - <;D<C-C><C-C>X>: Breakpoints clear
  - <;D<C-C><C-C>p>: Pause
  - <;D<C-C><C-C>f>: Dap local config
  - <;D<C-C><C-C>q>: UI close
  - <;D<C-C><C-C>g>: Get session
  - <;D<C-C><C-C>c>: Run to cursor
  - <;D<C-C><C-C>x>: Disconnect
  - <;D<C-C><C-L>>: Lua dap launch
  - <;D<M-7>>: Down
  - <;D<M-6>>: Up
  - <;D<M-5>>: Step out
  - <;D<M-4>>: Step over
  - <;D<M-3>>: Step into
- WARNING In mode `n`, <gb> overlaps with <gbc>:
  - <gb>: Comment toggle blockwise
  - <gbc>: Comment toggle current block
- WARNING In mode `n`, <gc> overlaps with <gcA>, <gcc>, <gcO>, <gco>:
  - <gc>: Comment toggle linewise
  - <gcA>: Comment insert end of line
  - <gcc>: Comment toggle current line
  - <gcO>: Comment insert above
  - <gco>: Comment insert below
- WARNING In mode `n`, <cx> overlaps with <cxx>:
  - <cx>: Exchange operator
  - <cxx>: Exchange operator
- WARNING In mode `n`, <cz> overlaps with <czz>:
  - <cz>: Substitute operator
  - <czz>: Substitute line
- WARNING In mode `i`, <<C-W>> overlaps with <<C-W>F>, <<C-W>N>, <<C-W>c>, <<C-W>C>, <<C-W><Right>>, <<C-W>d>, <<C-W>e>, <<C-W><Up>>, <<C-W>M>, <<C-W>a>, <<C-W><Down>>, <<C-W>u>, <<C-W>[>, <<C-W><Left>>, <<C-W>]>, <<C-W>W>, <<C-W>t>, <<C-W>m>, <<C-W>n>, <<C-W>R>, <<C-W>P>:
  - <<C-W>>: Window
  - <<C-W>F>: Close float windows
  - <<C-W>N>: Move buffer to next tab
  - <<C-W>c>: Close all visible windows
  - <<C-W>C>: Close all buffers
  - <<C-W><Right>>: Swap buffers right
  - <<C-W>d>: Duplicate window into new tab
  - <<C-W>e>: Equalize windows
  - <<C-W><Up>>: Swap buffers up
  - <<C-W>M>: Maximize height
  - <<C-W>a>: Toggle autowidth windows
  - <<C-W><Down>>: Swap buffers down
  - <<C-W>u>: Unsplit window
  - <<C-W>[>: Toggle collapse left windows
  - <<C-W><Left>>: Swap buffers left
  - <<C-W>]>: Toggle collapse right windows
  - <<C-W>W>: WinShift
  - <<C-W>t>: Break out into a new tab
  - <<C-W>m>: Maximize current window
  - <<C-W>n>: Create new tab
  - <<C-W>R>: Enter resize mode
  - <<C-W>P>: Move buffer to previous tab
- WARNING In mode `x`, <@> overlaps with <@(targets)>:
  - <@>: :help |v_@-default|
- WARNING In mode `x`, <i> overlaps with <iv>, <iN>, <iq>, <i_>, <im>, <ii>, <io>, <ig>, <iz>, <iS>, <i%>, <ik>:
  - <i>: inside
  - <iv>: inner value textobj
  - <iN>: inner notebookCell textobj
  - <iq>: inner anyQuote textobj
  - <i_>: inner lineCharacterwise textobj
  - <im>: inner chainMember textobj
  - <ii>: inner indentation
  - <io>: inner anyBracket textobj
  - <ig>: inner greedyOuterIndentation textobj
  - <iz>: inner closedFold textobj
  - <iS>: inner subword textobj
  - <ik>: inner key textobj
- WARNING In mode `x`, <a> overlaps with <av>, <aN>, <aq>, <a_>, <am>, <ai>, <ao>, <ag>, <az>, <aS>, <a%>, <ak>:
  - <a>: around
  - <av>: outer value textobj
  - <aN>: outer notebookCell textobj
  - <aq>: outer anyQuote textobj
  - <a_>: outer lineCharacterwise textobj
  - <am>: outer chainMember textobj
  - <ai>: outer indentation
  - <ao>: outer anyBracket textobj
  - <ag>: outer greedyOuterIndentation textobj
  - <az>: outer closedFold textobj
  - <aS>: outer subword textobj
  - <ak>: outer key textobj
- WARNING In mode `x`, <;D> overlaps with <;D<M-8>>, <;D<M-2>>, <;D<M-1>>, <;D<M-0>>, <;D<M-9>>, <;D<C-C><C-C>X>, <;D<C-C><C-C>p>, <;D<C-C><C-C>f>, <;D<C-C><C-C>q>, <;D<C-C><C-C>g>, <;D<C-C><C-C>c>, <;D<C-C><C-C>x>, <;D<C-C><C-L>>, <;D<M-7>>, <;D<M-6>>, <;D<M-5>>, <;D<M-4>>, <;D<M-3>>:
  - <;D>: Breakpoint toggle
  - <;D<M-8>>: Close
  - <;D<M-2>>: Continue
  - <;D<M-1>>: Breakpoint toggle
  - <;D<M-0>>: Toggle repl
  - <;D<M-9>>: Restart
  - <;D<C-C><C-C>X>: Breakpoints clear
  - <;D<C-C><C-C>p>: Pause
  - <;D<C-C><C-C>f>: Dap local config
  - <;D<C-C><C-C>q>: UI close
  - <;D<C-C><C-C>g>: Get session
  - <;D<C-C><C-C>c>: Run to cursor
  - <;D<C-C><C-C>x>: Disconnect
  - <;D<C-C><C-L>>: Lua dap launch
  - <;D<M-7>>: Down
  - <;D<M-6>>: Up
  - <;D<M-5>>: Step out
  - <;D<M-4>>: Step over
  - <;D<M-3>>: Step into
- WARNING In mode `s`, <;D> overlaps with <;D<M-8>>, <;D<M-2>>, <;D<M-1>>, <;D<M-0>>, <;D<M-9>>, <;D<C-C><C-C>X>, <;D<C-C><C-C>p>, <;D<C-C><C-C>f>, <;D<C-C><C-C>q>, <;D<C-C><C-C>g>, <;D<C-C><C-C>c>, <;D<C-C><C-C>x>, <;D<C-C><C-L>>, <;D<M-7>>, <;D<M-6>>, <;D<M-5>>, <;D<M-4>>, <;D<M-3>>:
  - <;D>: Breakpoint toggle
  - <;D<M-8>>: Close
  - <;D<M-2>>: Continue
  - <;D<M-1>>: Breakpoint toggle
  - <;D<M-0>>: Toggle repl
  - <;D<M-9>>: Restart
  - <;D<C-C><C-C>X>: Breakpoints clear
  - <;D<C-C><C-C>p>: Pause
  - <;D<C-C><C-C>f>: Dap local config
  - <;D<C-C><C-C>q>: UI close
  - <;D<C-C><C-C>g>: Get session
  - <;D<C-C><C-C>c>: Run to cursor
  - <;D<C-C><C-C>x>: Disconnect
  - <;D<C-C><C-L>>: Lua dap launch
  - <;D<M-7>>: Down
  - <;D<M-6>>: Up
  - <;D<M-5>>: Step out
  - <;D<M-4>>: Step over
  - <;D<M-3>>: Step into
- WARNING In mode `o`, <i> overlaps with <iv>, <iN>, <iq>, <i_>, <im>, <ii>, <io>, <ig>, <iz>, <iS>, <i%>, <ik>:
  - <i>: inside
  - <iv>: inner value textobj
  - <iN>: inner notebookCell textobj
  - <iq>: inner anyQuote textobj
  - <i_>: inner lineCharacterwise textobj
  - <im>: inner chainMember textobj
  - <ii>: inner indentation
  - <io>: inner anyBracket textobj
  - <ig>: inner greedyOuterIndentation textobj
  - <iz>: inner closedFold textobj
  - <iS>: inner subword textobj
  - <ik>: inner key textobj
- WARNING In mode `o`, <a> overlaps with <av>, <aN>, <aq>, <a_>, <am>, <ai>, <ao>, <ag>, <az>, <aS>, <a%>, <ak>:
  - <a>: around
  - <av>: outer value textobj
  - <aN>: outer notebookCell textobj
  - <aq>: outer anyQuote textobj
  - <a_>: outer lineCharacterwise textobj
  - <am>: outer chainMember textobj
  - <ai>: outer indentation
  - <ao>: outer anyBracket textobj
  - <ag>: outer greedyOuterIndentation textobj
  - <az>: outer closedFold textobj
  - <aS>: outer subword textobj
  - <ak>: outer key textobj
- WARNING In mode `n`, <yS> overlaps with <ySS>:
  - <yS>: Add a surrounding pair around a motion, on new lines (normal mode)
  - <ySS>: Add a surrounding pair around the current line, on new lines (normal mode)
- WARNING In mode `n`, <ys> overlaps with <yss>:
  - <ys>: Add a surrounding pair around a motion (normal mode)
  - <yss>: Add a surrounding pair around the current line (normal mode)
- OK Overlapping keymaps are only reported for informational purposes.
  This doesn't necessarily mean there is a problem with your config.

Checking for duplicate mappings ~
- WARNING Duplicates for <;D<C-c><C-c>f> in mode `x`:
  * Dap local config: `{ nowait = true, remap = false, rhs = "<Cmd>DAPLocal<CR>", silent = true }`
  * Dap local config: `{ nowait = true, remap = false, rhs = "<Cmd>DAPLocal<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-l>> in mode `x`:
  * Lua dap launch: `{ nowait = true, remap = false, rhs = "<Cmd>LuaDapLaunch<CR>", silent = true }`
  * Lua dap launch: `{ nowait = true, remap = false, rhs = "<Cmd>LuaDapLaunch<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>X> in mode `x`:
  * Breakpoints clear: `{ nowait = true, remap = false, rhs = "<Cmd>DapClearBreakpoints<CR>", silent = true }`
  * Breakpoints clear: `{ nowait = true, remap = false, rhs = "<Cmd>DapClearBreakpoints<CR>", silent = true }`
- WARNING Duplicates for <<D-v>> in mode `s`:
  * Paste from clipboard: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Paste from clipboard: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-q>> in mode `s`:
  * Exit: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Exit: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-w>> in mode `s`:
  * Close window: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Close window: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-t>> in mode `s`:
  * New tabgroup: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').new_tabgroup()<Cr>", silent = true }`
  * New tabgroup: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').new_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <<D-[>> in mode `s`:
  * Previous tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_previous_tabgroup()<Cr>", silent = true }`
  * Previous tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_previous_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <<D-]>> in mode `s`:
  * Next tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_next_tabgroup()<Cr>", silent = true }`
  * Next tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_next_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <<leader>rOl> in mode `n`:
  * Run last command - Flow: `{ nowait = true, remap = false, rhs = "<Cmd>FlowRunLastCmd<Cr>", silent = true }`
  * SnipLive: `{ nowait = true, remap = false, rhs = "<Cmd>SnipLive<Cr>", silent = true }`
- WARNING Duplicates for <<leader>xT> in mode `n`:
  * Run Current Test Class: `{ nowait = true, remap = false, rhs = "<cmd>XcodebuildTestClass<cr>", silent = true }`
  * Run Selected Tests: `{ nowait = true, remap = false, rhs = "<cmd>XcodebuildTestSelected<cr>", silent = true }`
- WARNING Duplicates for <<leader><leader>> in mode `n`:
  * Telescope buffers: `{ nowait = true, remap = false, rhs = "<cmd>Telescope buffers<cr>", silent = true }`
  * Telescope buffers: `{ nowait = true, remap = false, rhs = "<cmd>Telescope buffers<cr>", silent = true }`
- WARNING Duplicates for <<leader>dp> in mode `n`:
  * Print variable: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Print variable: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <g> in mode `n`:
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
- WARNING Duplicates for <<C-S-h>> in mode `n`:
  * Resize window right: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Resize window left: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<C-S-h>> in mode `t`:
  * Resize window right: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Resize window left: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<C-S-h>> in mode `i`:
  * Resize window right: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Resize window left: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<leader>rOr> in mode `v`:
  * SnipRun: `{ nowait = true, remap = false, rhs = "<Plug>SnipRun", silent = true }`
  * Run selected code (flow): `{ nowait = true, remap = false, rhs = "<Cmd>FlowRunSelected<CR>", silent = true }`
- WARNING Duplicates for <g> in mode `x`:
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
- WARNING Duplicates for <<leader>cc> in mode `x`:
  * Change text case: `{ nowait = true, remap = false, rhs = "<Cmd>TextCaseOpenTelescope<Cr>", silent = true }`
  * Change text case: `{ nowait = true, remap = false, rhs = "<Cmd>TextCaseOpenTelescope<Cr>", silent = true }`
- WARNING Duplicates for <g> in mode `v`:
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
  * [G]o: `{ group = true, icon = "󰎐", nowait = true, remap = false, silent = true }`
- WARNING Duplicates for <<D-v>> in mode `x`:
  * Paste from clipboard: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Paste from clipboard: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-q>> in mode `x`:
  * Exit: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Exit: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-w>> in mode `x`:
  * Close window: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Close window: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <<D-t>> in mode `x`:
  * New tabgroup: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').new_tabgroup()<Cr>", silent = true }`
  * New tabgroup: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').new_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <<D-[>> in mode `x`:
  * Previous tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_previous_tabgroup()<Cr>", silent = true }`
  * Previous tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_previous_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <<D-]>> in mode `x`:
  * Next tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_next_tabgroup()<Cr>", silent = true }`
  * Next tab: `{ nowait = true, remap = false, rhs = "<Cmd>lua require('utils.general').select_next_tabgroup()<Cr>", silent = true }`
- WARNING Duplicates for <;D> in mode `v`:
  * Breakpoint toggle: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
  * Breakpoint toggle: `{ nowait = true, remap = false, rhs = <function 1>, silent = true }`
- WARNING Duplicates for <;D<M-1>> in mode `v`:
  * Breakpoint toggle: `{ nowait = true, remap = false, rhs = "<Cmd>DapToggleBreakpoint<CR>", silent = true }`
  * Breakpoint toggle: `{ nowait = true, remap = false, rhs = "<Cmd>DapToggleBreakpoint<CR>", silent = true }`
- WARNING Duplicates for <;D<M-2>> in mode `v`:
  * Continue: `{ nowait = true, remap = false, rhs = "<Cmd>DapContinue<CR>", silent = true }`
  * Continue: `{ nowait = true, remap = false, rhs = "<Cmd>DapContinue<CR>", silent = true }`
- WARNING Duplicates for <;D<M-3>> in mode `v`:
  * Step into: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepInto<CR>", silent = true }`
  * Step into: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepInto<CR>", silent = true }`
- WARNING Duplicates for <;D<M-4>> in mode `v`:
  * Step over: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepOver<CR>", silent = true }`
  * Step over: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepOver<CR>", silent = true }`
- WARNING Duplicates for <;D<M-5>> in mode `v`:
  * Step out: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepOut<CR>", silent = true }`
  * Step out: `{ nowait = true, remap = false, rhs = "<Cmd>DapStepOut<CR>", silent = true }`
- WARNING Duplicates for <;D<M-6>> in mode `v`:
  * Up: `{ nowait = true, remap = false, rhs = "<Cmd>DapUp<CR>", silent = true }`
  * Up: `{ nowait = true, remap = false, rhs = "<Cmd>DapUp<CR>", silent = true }`
- WARNING Duplicates for <;D<M-7>> in mode `v`:
  * Down: `{ nowait = true, remap = false, rhs = "<Cmd>DapDown<CR>", silent = true }`
  * Down: `{ nowait = true, remap = false, rhs = "<Cmd>DapDown<CR>", silent = true }`
- WARNING Duplicates for <;D<M-8>> in mode `v`:
  * Close: `{ nowait = true, remap = false, rhs = "<Cmd>DapClose<CR><Cmd>DapDisconnect<CR><Cmd>DapUIClose<CR>", silent = true }`
  * Close: `{ nowait = true, remap = false, rhs = "<Cmd>DapClose<CR><Cmd>DapDisconnect<CR><Cmd>DapUIClose<CR>", silent = true }`
- WARNING Duplicates for <;D<M-9>> in mode `x`:
  * Restart: `{ nowait = true, remap = false, rhs = "<Cmd>DapRestart<CR>", silent = true }`
  * Restart: `{ nowait = true, remap = false, rhs = "<Cmd>DapRestart<CR>", silent = true }`
- WARNING Duplicates for <;D<M-0>> in mode `x`:
  * Toggle repl: `{ nowait = true, remap = false, rhs = "<Cmd>DapToggleRepl<CR>", silent = true }`
  * Toggle repl: `{ nowait = true, remap = false, rhs = "<Cmd>DapToggleRepl<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>c> in mode `x`:
  * Run to cursor: `{ nowait = true, remap = false, rhs = "<Cmd>DapRunToCursor<CR>", silent = true }`
  * Run to cursor: `{ nowait = true, remap = false, rhs = "<Cmd>DapRunToCursor<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>p> in mode `x`:
  * Pause: `{ nowait = true, remap = false, rhs = "<Cmd>DapPause<CR>", silent = true }`
  * Pause: `{ nowait = true, remap = false, rhs = "<Cmd>DapPause<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>x> in mode `x`:
  * Disconnect: `{ nowait = true, remap = false, rhs = "<Cmd>DapDisconnect<CR>", silent = true }`
  * Disconnect: `{ nowait = true, remap = false, rhs = "<Cmd>DapDisconnect<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>g> in mode `x`:
  * Get session: `{ nowait = true, remap = false, rhs = "<Cmd>DapGetSession<CR>", silent = true }`
  * Get session: `{ nowait = true, remap = false, rhs = "<Cmd>DapGetSession<CR>", silent = true }`
- WARNING Duplicates for <;D<C-c><C-c>q> in mode `x`:
  * UI close: `{ nowait = true, remap = false, rhs = "<Cmd>DapUIClose<CR>", silent = true }`
  * UI close: `{ nowait = true, remap = false, rhs = "<Cmd>DapUIClose<CR>", silent = true }`
- OK Duplicate mappings are only reported for informational purposes.
  This doesn't necessarily mean there is a problem with your config.

Log

Debug Started for v3.13.2
{
  branch = "main",
  commit = "6c1584eb76b55629702716995cca4ae2798a9cca"
}
new Mode(n:1)
BufNew(5)
BufEnter(5)
  new Mode(n:5)
BufNew(6)
BufEnter(6)
  new Mode(n:6)
BufEnter(6)
on_key: <Space>pl
BufNew(9)
BufNew(10)
BufNew(11)
BufNew(12)
BufNew(13)
BufNew(14)
BufNew(15)
BufNew(16)
BufNew(17)
BufNew(18)
BufNew(19)
BufEnter(19)
  new Mode(n:19)
BufNew(20)
BufEnter(20)
  new Mode(n:20)
BufEnter(5)
BufReadPost(15)
BufEnter(15)
  new Mode(n:15)
BufEnter(19)
BufReadPost(16)
BufEnter(16)
  new Mode(n:16)
BufReadPost(17)
BufEnter(17)
  new Mode(n:17)
BufEnter(16)
BufEnter(20)
BufEnter(16)
Trigger(add) Mode(n:1) ' ` " g' g` Z ] [ z ; = <Plug> <C-W> g <Space> \
Trigger(add) Mode(n:17) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
Trigger(add) Mode(n:16) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
Trigger(add) Mode(n:15) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
Trigger(add) Mode(n:20) ' ` " g' g` Z ] [ z <Space> ; = <Plug> <C-W> g \
BufNew(28)
BufNew(29)
BufNew(30)
BufNew(31)
BufNew(32)
BufEnter(32)
  new Mode(n:32)
BufEnter(32)
Trigger(add) Mode(n:32) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
LspAttach(17)
  Trigger(del) Mode(n:17) g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g ' ` "
LspAttach(16)
  Trigger(del) Mode(n:16) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
LspAttach(15)
  Trigger(del) Mode(n:15) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
BufNew(35)
BufNew(36)
on_key: <C-,>
BufNew(37)
BufEnter(37)
  new Mode(n:37)
Trigger(add) Mode(n:37) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
on_key: <C-;>
on_key: <C-L>
BufEnter(16)
  new Mode(n:16)
Trigger(add) Mode(n:16) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
on_key: <LeftRelease>
on_key: ;
State(start): Mode(n:0) Node(;) { keys = ";" }
  update Mode(n:16)
  continue: ; Mode(n:16)
  getchar
  on_key: D
  got: D
  suspend: Mode(n:16)
  Trigger(del) Mode(n:16) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g
  feedkeys: Mode(n:16) ;D
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  suspend: Mode(n:16)
  feedkeys: Mode(n:16) ;D
  executed
on_key: ;D
State(start): Mode(n:0) Node(;D) { delay = 0, keys = ";D", loop = true, waited = 1000 }
  update Mode(n:16)
  BufNew(40)
  recursion detected. Aborting
BufNew(41)
on_key: <C-H>
BufEnter(37)
Trigger(add) Mode(n:16) ' ` " g' g` Z ] [ z <Space> \ ; <Plug> <C-W> g

Repro

wk.add({
    {
      mode = { "n", "x", "v" },
      buffer = nil,
      silent = true,
      noremap = true,
      nowait = true,
      {
        ";D",
        function()
          require("which-key").show({
            keys = ";D",
            loop = true, -- this will keep the popup open until you hit <esc>
          })
        end,
        desc = "Breakpoint toggle",
      },
      { ";D<M-1>", "<Cmd>DapToggleBreakpoint<CR>", desc = "Breakpoint toggle" },
      { ";D<M-2>", "<Cmd>DapContinue<CR>", desc = "Continue" },
      { ";D<M-3>", "<Cmd>DapStepInto<CR>", desc = "Step into" },
      { ";D<M-4>", "<Cmd>DapStepOver<CR>", desc = "Step over" },
      { ";D<M-5>", "<Cmd>DapStepOut<CR>", desc = "Step out" },
      { ";D<M-6>", "<Cmd>DapUp<CR>", desc = "Up" },
      { ";D<M-7>", "<Cmd>DapDown<CR>", desc = "Down" },
      { ";D<M-8>", "<Cmd>DapClose<CR><Cmd>DapDisconnect<CR><Cmd>DapUIClose<CR>", desc = "Close" },
      { ";D<M-9>", "<Cmd>DapRestart<CR>", desc = "Restart" },
      { ";D<M-0>", "<Cmd>DapToggleRepl<CR>", desc = "Toggle repl" },
      { ";D<C-c><C-c>c", "<Cmd>DapRunToCursor<CR>", desc = "Run to cursor" },
      { ";D<C-c><C-c>p", "<Cmd>DapPause<CR>", desc = "Pause" },
      { ";D<C-c><C-c>x", "<Cmd>DapDisconnect<CR>", desc = "Disconnect" },
      { ";D<C-c><C-c>g", "<Cmd>DapGetSession<CR>", desc = "Get session" },
      { ";D<C-c><C-c>q", "<Cmd>DapUIClose<CR>", desc = "UI close" },
      { ";D<C-c><C-c>f", "<Cmd>DAPLocal<CR>", desc = "Dap local config" },
      { ";D<C-c><C-l>", "<Cmd>LuaDapLaunch<CR>", desc = "Lua dap launch" },
      { ";D<C-c><C-c>X", "<Cmd>DapClearBreakpoints<CR>", desc = "Breakpoints clear" },
    },
  })
@Ajaymamtora Ajaymamtora added the bug Something isn't working label Aug 2, 2024
@max397574
Copy link
Contributor

max397574 commented Aug 5, 2024 •
edited
Loading

I think the problem here is that you map ;D to show which key for ;D similar to this issue #714
I would

  1. try to map a different key to this to see if this is really the problem here
  2. try to remove the nowait because that might cause problems here because ;D will instantly execute the mapping and the mapping maps to show which key again -> recursion

perhaps this is somehow doable with the triggers option
even though it seems like you can't add the loop thing there
but that option should normally be used to accomplish what you want here (well actually if it weren't for the loop option this would require no additional setup)

@Ajaymamtora
Copy link
Author

I think the problem here is that you map ;D to show which key for ;D similar to this issue #714 I would

  1. try to map a different key to this to see if this is really the problem here
  2. try to remove the nowait because that might cause problems here because ;D will instantly execute the mapping and the mapping maps to show which key again -> recursion

perhaps this is somehow doable with the triggers option even though it seems like you can't add the loop thing there but that option should normally be used to accomplish what you want here (well actually if it weren't for the loop option this would require no additional setup)

Okay just setting no wait to false stops the infinite loop, but some of those mappings cause hydra to close, I've gone back to nvimtools/hydra instead for now, feel free to close

@max397574
Copy link
Contributor

max397574 commented Aug 6, 2024 •
edited
Loading

In my opinion this should stay open because it isn't clear how this should be done correctly
I'd assume it is how you've done it (without the nowait) but then this is a bug when the menu is closed sometimes

@mintelm
Copy link

mintelm commented Aug 8, 2024

Yeah, I'm also interested in this feature. I also tried to use the loop feature, however, I had the same issues and also went back to nvimtools/hydra, but I'd prefer to use which-key.nvim if it can simulate the behavior of hydra.

@github-actions GitHub Actions
Copy link
Contributor

github-actions bot commented Sep 8, 2024

This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.

@github-actions github-actions bot added the stale label Sep 8, 2024
@Ajaymamtora
Copy link
Author

.

@github-actions github-actions bot removed the stale label Sep 9, 2024
@mintelm
Copy link

mintelm commented Oct 7, 2024

any updates or progress on the issue?

@github-actions GitHub Actions
Copy link
Contributor

github-actions bot commented Nov 7, 2024

This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 7 days.

@github-actions github-actions bot added the stale label Nov 7, 2024
@ANGkeith ANGkeith mentioned this issue Nov 10, 2024
Open
@github-actions GitHub Actions
Copy link
Contributor

This issue was closed because it has been stalled for 7 days with no activity.

@github-actions github-actions bot closed this as not planned Won't fix, can't repro, duplicate, stale Nov 14, 2024
@kasi-x
Copy link

kasi-x commented Nov 14, 2024

I think this is very important issue for many users.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
bug Something isn't working stale
Projects
None yet
Milestone
No milestone
Development

Successfully merging a pull request may close this issue.

fix(state): recursion in hydra mode when mapping does not exist ANGkeith/which-key.nvim
4 participants
@Ajaymamtora @mintelm @max397574 @kasi-x