Undo-joining a mapping that uses the expression register

Question

I'm trying to make semi-automatic parentheses work using vim-arpeggio and ultisnips. Everything works fine except the undo story. What I have now is this:

Arpeggioinoremap () ()<c-r>=UltiSnips#ExpandSnippet()<cr>

in the .vimrc and

snippet () "paren" i
($1)$0
endsnippet

in my snippets file.

What this does is this: When I type () in very close succession, arpeggio will trigger its mapping. The mapping reinserts the same characters, then enters the expression register where it calls the ultisnips expand function for its side effect of replacing the () characters with the expanded snippet. I end up the the pointer between the parentheses.

I like this solution because it does not replace () with anything when typed at normal speed. It's really only the simultaneously typed parens that get interpreted specially.

What does not work: undoing all of the mapping in one go. When I hit u, I get back to the stage where () is already entered. I was unable to find out how to make undojoin work here. UltiSnips#ExpandSnippet appears to work only in insert mode, so I cannot simply exit into normal mode and call :undojoin | eval UltiSnips#ExpandSnippet(), at least so it appears.

EDIT: the problem is not related to the arpeggio plugin. the same necessity for a double undo appears with

inoremap () ()<c-r>=UltiSnips#ExpandSnippet()<cr>

EDIT 2: I mis-stated the problem above, sorry for that! What's actually the problem is this:

After pressing u the expansion is undone and the cursor remains between (). The next undo again reproduces () without change. I believe this is because Arpeggio and Ultisnips both set an undo mark so to speak. I would like to get rid of the need for undoing twice. The desired behavior is: press u once, get (). Press u again, undo the previous text edit that includes insertion of ().

context: I have several more parentheses pairs defined in a similar way, for instance ;' which on my keyboard amounts to hitting the single quotation mark and the key left of it together. This is then mapped to '' by Arpeggio and further expanded to '$1'$0 by Ultisnips. Pressing undo once here gives '' and pressing it again, gives ;' which is undesired.

Answer 1

Background

UltiSnips#ExpandSnippet() actually breaks the undo sequence twice, once before expansion, and another after the expansion. More precisely, UltiSnips#ExpandSnippet() calls snippet_manager.expand(), which calls snippet_manager._try_expand(). Inspecting the code for _try_expand(), we see that it

1. starts an undo sequence
2. expands the snippet (via _do_snippet())
3. starts another undo sequence.

A quick remedy

I recommend to comment out line 819 to remove the second undo sequence (step 3). Note that for the () snippet, removing either one of the two undo sequences will work. However, this is not the case for the if the characters differ. For example, if a qq snippet expands to '', then fooqqbar will become

  fooqq 
  -undo point-
  foo''
  -undo point-
  foo'bar'

If the second undo sequence was removed, a single undo would leave you with foo'', and not fooqq.

Addendum

Now, in place of commenting out that line, one could create an option to enable/disable that behavior, and submit a PR on the repository!

Answer 2

Besides UltiSnips#ExpandSnippet(), there is also UltiSnips#Anon(). The latter expands a snippet that is defined on-the-fly. Importantly, unlike UltiSnips#ExpandSnippet(), UltiSnips#Anon() does not break the undo sequence.

Thus you could modify the Arpeggio mapping to

Arpeggioinoremap () <c-r>=UltiSnips#Anon('($1)$0')<cr>

in your vimrc. The lines in the snippets file can also be removed, unless you really wish to expand () manually.