How do you index code in your projects?

I used to use tags and now I use an LSP client (the one shipped with Neovim v0.5). I find that trying to use the CLI to discover semantic information about your code doesn’t work past a certain amount of lines of code. I still regularily make use of grep, both in a terminal and with a “fuzzy” matcher (denite) but the larger the project the less I’ll use it. For working on Firefox and Linux I prefer using https://searchfox.org/ and https://elixir.bootlin.com/linux/latest/source though.

Additionally, from lurking round the web, I get the impression that ctags (and alternatives) aren’t really used anymore or that there’s now a better way of supporting jump-to-symbol in Vim. Is this accurate and, if so, what’s the new alternative?

I would say that it is accurate and that the alternative is LSP clients and servers.

I use an IDE, which indexes the project and provides instant method/function signatures, jump to definition, find usages, refactoring, etc etc.

Heh, I personally just implement the thing myself (1, 2) :)

More practically, I think there are these choices available:

• use smart IDE, like IntelliJ
• use editor with LSP support (and bug LSP, editor and server developers to improve support for this, as they don’t allow you to filter your code vs library code, or test vs main code)
• produce symbol index as a part of build process (Google’s kythe).
• use offline regex based index (ctags). This works well enough, but might not be super precise (as regexes can’t parse programming languages), and have a drawback that index rebuild must be triggered manually.

The next two options are a straightforward (Christmas holidays scale) extensions to the last one, but I don’t think they are available as a popular stand-alone tool.

• online indexing – listen for the file changes and apply an incremental diff to the index, rather than recomputing it from scratch
• plug tree sitter instead of regular expressions for richer and more correct indexes.

In Emacs I use a mixture of plain grep/ripgrep/whatever, vc-git-grep, and GNU Global with ggtags-mode. Most of the time I lean on Global and it is decent, but misses many use cases that LSP (when I have used it) can catch. I mainly work on a GCC code base, which is rather large, and the plain grep/ripgrep/whatever is just too slow. Global is much faster. If I’m searching for something in the repo, ‘vc-git-grep` is the clear winner. If it’s in the generated build files, grep is fine.

I did try LSP but because it has to hook into the build a specific way it’s a bit clunky to use in the GCC build. I’ve been meaning to try it out again but what I have now works pretty well and the motivation to change isn’t sufficient right now.

cscope still works well for me - I find it very easy to use, and I’ve used it on very large codebases. The indexing time is not significant.

I do not use completion frameworks, but that’s a personal choice.

In the past, for Vim, I’ve used vim-gutentags to run ctags and that has been alright. My main issues are that it can be slow (and cpu intensive) for very large projects, and you have to manage this tags file (though that isn’t the end of the world).

I use my own ctags wrapper (a whopping 24 lines of VimScript!) with a set of heuristics that assemble an exclude list (so you don’t waste time parsing crap in node_modules, generated files, caches, virtualenv dirs, etc). I don’t even use a Vim tags plugin - I just bind that function to a hotkey.

It looks like a ghetto solution, but it’s been working surprisingly well for me. I haven’t touched that code in years, and I use ctags every day!

I use emacs and mostly write go. In the past I used godef integration to jump to definition: (C-c j). I’ve been experimenting a bit with lsp which provides the same functionality.

I also have come to really like Google’s code search indexing abilities. Both for autocomplete proper regex search and for references/jump to definition. For example load this up: https://source.chromium.org/chromium/chromium/src/+/master:chrome/chrome_proxy/chrome_proxy_main_win.cc;l=19;bpv=1;bpt=1

click on kChromeProxyExecutable and you’ll get a list of where it’s used. Click on FILE_PATH_LITERAL and it will jump to definition.

[edit] Oh, and grep still. Sometimes your tooling doesn’t understand the project definition/layout.

For my projects I’m really using IDEs (Intellij ones + IdeaVim) that have this out of the box. When I was experimenting with using Vim as an IDE, I was using LSP servers (coc-vim), ripgrep and my own few-line scripts that were performing simple tasks across whole codebases. For libraries that mostly went unmodified, but from some reason I had to have indexing support for them, I’ve used ctags, gtags and an opengrok instance which I use to explore the unknown codebase.

I aliased this script to “findcode”:

IFS=$'\n'
find .                  \
     -type f            \
     ! -path '*/.git/*' \
     -name "*.$2"       \
     -exec grep -Hi --color=auto -- "$1" {} \;

So when I want to find lines in my codebase that contain “carWashFactory”, I type:

findcode carwashfactory php

I just use a CLI grepper. Common ones these days are ag, ack and ripgrep. I admit that in-IDE indexed jumping is probably superior when you’re trying to look up things that are in third-party libraries, but, otherwise, I’m content with CLI for in-codebase searches.

For most of languages I use LSP. The main advantage is that it understands the language and knows where to find definitions, find usages, perform renames, display documentation. The disadvantage is that some implementations of servers are slow, (or all of them are slow, depends on your definition of slow).

With the dev version of Neovim, I use LSP whenever possible. The integration is much better than grepping around (that I used to do).

Not. I use plain grep in a terminal. Keeps me aware of the general structure of the project.

LSP and Universal Ctags (not Exuberant Ctags which are distributed with most systems as ctags). Sometimes I go with :grep in Vim, but in most cases above tools are more than enough for my needs.

On my main development machine I have neovim and just greps. As most of the things I work on tend to break graphics, terminal, … on a regular basis, there is a second machine that doubles as local CI, ‘man viewer’ and backup. That machine also indexes and browses using the rather awesome sourcetrail (https://github.com/CoatiSoftware/Sourcetrail ) - would love a CLI/TUI to it though ..

I don’t. I just use Notepad++. As long as the project is below 100k LoC and I wrote everything myself, I don’t need it. For larger projects at work, I use Eclipse CDT (for C/C++). I’ve also been looking into Visual Studio Code combined with Rust Language Server (RLS), that looks pretty promising and has helped me out a couple of times.

ctags -R, then vim bindings to search

[Comment removed by author]