Get ctags in vim to go to definition, not declaration

I believe Vim goes to the first tag in the tags file by default. You can select a different one if you prefer: use :tj (similar to :tselect, but auto-jump if there's only one match) or Ctrl-] followed by :tn).

The only way of changing the default is to change the order of the tags file, but I don't believe ctags offers a command-line option to do this.

This isn't as hard as it sounds as you basically need a script that opens the tags file, sorts it by the 'kind' of tag and writes it back out again. The 'kind' in the tag is a single character describing whether it's a function (f), a function prototype (p), a macro, a enumerated name etc etc etc. If you're using Linux, it could, in theory, be as simple as:

#!/bin/sh
ctags -R -f - . | tac > tags

Since tac reverses the order of lines in a file, this will automatically put the definition first. However, it gets a bit more complicated as the header needs to be maintained and Vim prefers the tag file to be sorted, so it's better to go through the file and sort on the first entry (the tag name) in forward order and then the kind in reverse order. Therefore, something more complicated may be better.

I apologise for the shameless plug, but I have written a Vim plugin that (indirectly) does what you need. It is intended for adding lots of extra highlighting groups for things like function names, macros, enums etc. However, one of the other things that this does is re-sort the tag file so that the function implementation comes before the function declaration, thereby achieving what you want (I had the same need as you). If you don't want any of the highlighting functionality, you could probably strip it all out quite easily: it's a fairly simple python program and an even simpler Vim script and is available from my site.

You should be able to use tn and tp to jump to the various matching tags.

• Press ^] to take you to the first match.
• If that's not the match you want, type :tn to go to the next.
• If you typed :tn too many times you can type :tp to return to the previous one.

Late to the party, but for incoming vim tag googlers:

I've found that using cscope in addition to ctags is the way to go, at least for C/C++. It's more intelligent about call trees, and you can set it to fallback to ctags if it fails. Just run "cscope -b" everytime you run ctags -R . and you'll be ready to go. If you use the settings below, you'll be able to use Ctrl-]/Ctrl-T like always, but you can also add nifty new jumps like jumping to a function declaration and showing a jumplist of function callers.

" setup
if has("cscope")
    set csto=0                                                                             
    set cst
    set nocsverb
    " add any database in current directory
    if filereadable("cscope.out")
    cs add cscope.out
    " else add database pointed to by environment
    elseif $CSCOPE_DB != ""
    cs add $CSCOPE_DB
    endif
    set csverb
endif

" jump to a function declaration
nmap <silent> <C-\> :cs find s <C-R>=expand("<cword>")<CR><CR>1<CR><CR>
" show a list of where function is called
nmap <silent> <C-_> :cs find c <C-R>=expand("<cword>")<CR><CR>

:tselect my_little_function 

and you would get a list of matches. or if you jump to a tag and you are not happy with it, then type

:tselect

And you get a list of alternative for the last active tag.

This can happen because the pattern match stored in the tags file finds the declaration before the definition.

When Exuberant Ctags creates an entry for an identifier, it adds the entire containing line as a match.

However, sometimes the forward declaration matches that pattern. This can happen under certain coding styles.

First, here is an example file, foo.c which doesn't have this problem:

static int foo(int x);
static int foo(int x)
{
}

Ctags creates an entry which looks like this:

foo foo.c   /^static int foo(int x)$/;" f   file:   signature:(int x)

The match is anchored with ^ and $, and since the forward declaration ends with ;, it does not match.

However, the following coding convention triggers the issue:

static int foo(
 int x
);

static int foo(
  int x
)
{
}

The tags entry is now:

foo foo.c   /^static int foo($/;"   f   file:   signature:( int x )

This will find the first line of the declaration, which is indistinguishable from the first line of the definition.

The fix is to make these two somehow different, while staying within the coding convention. In this case we are in C, so one thing we can do is drop the static from the definition.

A C file scope declaration that has no storage class specifier declares a name with linkage. The linkage type (internal or external) is inherited from any previous declaration of the name that specified linkage. Thus:

static int foo(
 int x
);

int foo(
  int x
)
{
}

And now the tag looks like:

foo foo.c   /^int foo($/;"  f   signature:( int x )

which matches only the definition; Vim no longer jumps to the first declaration.

If this solution is not workable, then it may be necessary to write a tags filtering tool which scans the tags file and identifies this problem, fixing up the offending tags. For example, for the second file with the ambiguous lines, we can fix up the tag manually like this:

foo     foo.c   /^static int foo($/;/^static int foo($/;"       f       file:   signature:( int x )

I added a second Ex command into the tag-address, to search for the same pattern again. Now it jumps to the correct line. (Note: however, this is broken if the forward declaration is the very first line of the file.)

Finding ambiguous tags which have more than one match in the file and editing them in the above manner (or some other idea) can be automated, turned into a post-processing pass done each time the tags file is generated. The additional scan of the files is expensive, though; this really should be done in Ctags.