Wsrtjtyk

I am trying to read a lot of C/Perl code through Vim which contain many single letter variable names.

It would be nice to have some command which could help me change the name of a variable to something more meaningful while I'm in the process of reading the code so that I could read the rest of it faster.

Is there some command in Vim which could let me quickly do this?

I don't think regexes would work because:

1. the same single letter name might have different purposes in different scoping blocks




2. the same combination of letters could be part of another larger var name, or in a string or comment... would not want to modify those

Any known solutions?

The following is how to rename a variable which is defined in the current scope {}.

Move your cursor to the variable usage. Press gd. Which means - move cursor to the definition.
Now Press [{ - this will bring you to the scope begin.
Press V - will turn on Visual Line selection.
Press % - will jump to the opposite } thus will select the whole scope.
Press :s/ - start of the substitute command.
<C-R>/ - will insert pattern that match variable name (that name you were on before pressing gd).
/newname/gc<CR> - will initiate search and replace with confirmation on every match.

Now you have to record a macros or even better - map a key.

Here are the final mappings:

" For local replace

nnoremap gr gd[{V%::s/<C-R>///gc<left><left><left>



" For global replace

nnoremap gR gD:%s/<C-R>///gc<left><left><left>

Put this to your .vimrc or just execute.
After this pressing gr on the local variable will bring you to :s command where you simply should enter new_variable_name and press Enter.

AFAIK, there is no actual refactoring support in VIM. When doing a rename with the intent of a refactor I usually take the following precautions:

1. Limit the scope of the change my using marks.


2. When entering the regex, bracket the name with < and >. This will make it match an entire word which reduces the types of incorrect renames that will occur.


3. Don't do a multiline replace to reduce chances of a bad replace


4. Look through the code diff carefully if it's anything other than a small change.

My end change looks something like this

:'a,'bs/<foo>/bar

I would love to be wrong about there not being a refactoring tool for VIM but I haven't seen it.

Put this in your .vimrc

" Function to rename the variable under the cursor

function! Rnvar()

  let word_to_replace = expand("<cword>")

  let replacement = input("new name: ")

  execute '%s/(W)' . word_to_replace . '(W)/1' . replacement . '2/gc'

endfunction

Call it with :call Rnvar()

expand("<cword>") gets the word under the cursor. The search string uses % for file-scope, and the (W) patterns look for non-word characters at the boundary of the word to replace, and save them in variables 1 and 2 so as to be re-inserted in the replacement pattern.

I know it's an old question, and @mykola-golubyev's way obviously IS the best answer for the particular case in the OP question (which, I assume is going through obfuscated code where you're likely to have multiple blocks with same var names); but with the question name like that many people coming here from google searches probably look for a less situation-specific ways to rename variables in VIM -- and those can be more concise

I'm surprized no one suggested this way:

* :s// NEWNAME /gc

The * is the same as gn - it searches for the next occurence of the word under cursor AND it becomes the last searched pattern, so when you omit the search pattern in the substitute command, VIM assumes this is the pattern to search for.

For small amounts of var copies, an even quicker one:

* cw NEWNAME <esc> then repeat n. for other occurrences

Search for occurrence, cw is command for change word, n goes to next occurrence for last search and . repeats the last command (which is change word to NEWNAME)

(Credits for me knowing all this go to @doomedbunnies on Reddit)

Another cool trick is this: (credits to @nobe4)

* cgn NEWNAME <esc> then repeat . for other occurrences

cgn is "change whatever is the result of (find next occurrence)". Now that this is the last command, you don't need the n to go to the next occurrence, so fewer strokes again, and, more importantly, no need to alternate n and .. But, obviously, this one has the drawback of not having a way to skip an occurrence.

Here are some benefits:

• no mapping, no .vimrc(or init.vim), so you can use it in any VIM copy you come across (e.g. a quick task on some VPS or your friend's machine where configuring VIM your way would defeat the purpose of 'quick')


• using * or gn for word selection is very quick -- just one keystroke (well, let's say 1.5)


• using * or gn makes sure you don't get any matches inside other words, just as :%s/<C-R>//gc does. Beats typing the :%s/<OLDNAME>/NEWNAME/gc by hand: I personally tend to forget to use the < things to limit matches to whole words only.


• Not using scope will only result in a few extra strokes of n to skip unwanted matches -- probably even fewer than the extra strokes needed to limit the scope. Under normal curcumstances, your variables are most likely somewhat localized to a certain code block anyway.