andersbakken/rtags

A client/server indexer for c/c++/objc[++] with integration for Emacs based on clang.

rtags

rtags-xref	ac-rtags	company-rtags	flycheck-rtags	helm-rtags	ivy-rtags

Introduction

RTags is a client/server application that indexes C/C++ code and keeps a persistent file-based database of references, declarations, definitions, symbolnames etc. There’s also limited support for ObjC/ObjC++. It allows you to find symbols by name (including nested class and namespace scope). Most importantly we give you proper follow-symbol and find-references support. We also have neat little things like rename-symbol, integration with clang’s “fixits” (https://clang.llvm.org/diagnostics.html). We also integrate with flymake using clang’s vastly superior errors and warnings. Since RTags constantly will reindex “dirty” files you get live updates of compiler errors and warnings. Since we already know how to compile your sources we have a way to quickly bring up the preprocessed output of the current source file in a buffer.

While existing taggers like gnu global, cscope, etags, ctags etc do a decent job for C they often fall a little bit short for C++. With its incredible lexical complexity, parsing C++ is an incredibly hard task and we make no bones about the fact that the only reason we are able to improve on the current tools is because of clang (https://clang.llvm.org/). RTags is named RTags in recognition of Roberto Raggi on whose C++ parser we intended to base this project but he assured us clang was the way to go. The name stuck though.

Tarball releases are available here: https://github.com/Andersbakken/rtags/releases/

TLDR Quickstart

We assume you have something to generate a JSON Compilation Database for your project. Your build system probably has a way to generate it, or you can look at something like Bear.

Build RTags

git clone --recursive https://github.com/Andersbakken/rtags.git
cd rtags
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 .
make

Start the RTags daemon (rdm)

./bin/rdm &

Index the RTags project, and wait until rdm is silent

./bin/rc -J .

Open source file in emacs

emacs +74:34 src/rdm.cpp

Load rtags.el

M-: (load-file "rtags.el") RET

Ensure rc can be found

M-x set-variable RET rtags-path RET "../bin" RET

Call rtags-find-symbol-at-point

M-x rtags-find-symbol-at-point RET

Your location is now on the definition of Server::instance()

Documentation

The documentation can be found in the Wiki.

Disclaimer

RTags is still under development and is not the most stable piece of software you’ll ever find. We’re constantly working to improve on it.

rtags's Issues

Should consider having a mode where we take over GCC (like icecream) to parse makefiles

find references to round doesn't work well.

preemptively cache completions in rdm

Forward declarations are not linked to their definitions, neither are references to the forward declaration

suspicious call to assert()

Hi,

I think there is a typo here :

            case '(':
                assert(from = -1);
                from = j;

rtags/src/rdm.cpp

Line 34 in dc56034

assert(from = -1);

I don't think the side effect is expected, you probably just want to check the equality.

We should sort output from rtags-all-references-at-point with definitions first (like we do for rtags-find-symbol)

Sorting of symbols should take cursor kind into account.

There's some code in there that tries to do that but it doesn't seem to work.

QueryMessage::WaitForIndexing doesn't work (I think)

Add a function to preprocess a source file using the known arguments (using gcc?) and dump out the output

Templatized functions do not work entirely right

Can't follow this symbol in Connection.h:

template bool Connection::send(const T *message)
{
return send(...
} /
||

This might just be the way it is. Maybe we could do something along the lines of not blocking template functions cursors since they maybe appear different in translation units where they are used vs when they are not used.

support ninja

ninja -t or something like that gives us everything we need.

rtags-rename-symbol should use c-beginning-of-token to find bounds

Store cursorextent in cursorinfo

For tooltip information or something similar.

we should reintroduce a database that allows us to not have to reindex everything on startup

clang_getCursorReferenceNameRange might be useful for something. Investigate.

rtags-set-current-project doesn't quite work anymore

rtags --project should be a flag as well as a command

completion cache should save current line up to column and compare before using it

We need a solution for Process and shell scripts (for Preprocess)

Maybe read first two bytes, if #! then invoke with specified interpreter

rc -s needs some love

We should try to get more awesome warnings and errors (like the mac system compiler gets)

We're having issues with MakefileParser for openssl

For openssl eatAutoTools is the culprit. Apparently DirectFB works pretty nicely in 1.6.1

Should consider ditching the unix socket in favor of shared memory and system semaphores

http://www.drdobbs.com/creating-stl-containers-in-shared-memory/184401639

Process should support startDetached. Then we could kill RTags::startProcess

diagnostics needs to cache more appropriately

rtags-find-virtual-methods doesn't find "siblings"

E.g.

struct Base
{
virtual void foo() {} // <- this finds everything
};

struct One : public Base
{
virtual void foo() {} // <- this only finds itself and Base::foo()
}

struct Two : public Base
{
virtual void foo() {}
}

we should update modeline or what-function with name of current cursor (or target)

Still at least one problem with constructors

struct F
{
F();
F(const F &f) {}
};

int main()
{
F f = F();
}

somehow the F() call refers to the struct F, not the default
constructor, also, f does not refer to the copy constructor.

Trying to improve the current hacks in origin/workonstupidconstuctor

we should go to beginning of symbol before calling follow-location and find-references

This will work better for busted symbols with symbollength == 0

There seems to be a bug with the filesystem watcher on mac

When doing a git rebase -i it never gets triggered.

diagnostics scrolls to bottom for some reason

tokenize properly to determine completion point

try to hook into existing libtooling refactoring tools

Make it possible to autoupdate project from current emacs file/default-directory

case insensitive completions (symbolname, path)

Make completion use ido somehow

Currently ido-completing-read doesn't let you pass functions to gather data. Smex seems to let us do it though. Investigate.

We have crashes when files get removed

delete on iterators doesn't work.

signal handler should remove server file, figure out what to about clang's signal handler

We should have a query for dumping out verbosevisit results for a particular file.

We could handle queries while parsing more gracefully. Hanging emacs until the project finishes parsing is not really that cool

FileSystemWatcher issue with fsevents and kqueue

The kqueue and fsevents watchers both have an issue where if you watch /foo,
then /foo/bar and then unwatch /foo then none of the paths are watched.
In addition, the kqueue watcher has an issue where if you watch /foo/bar,
then watch /foo and then unwatch /foo, then /foo/bar is no longer watched either.

Display source for target cursor in a tooltip

when hovering over in GUI emacs

Alternatively display in a buffer.

Job and Connection should have snprint-like functions for convenience.

preprocess doesn't work with icecream

When compiler points to icecc we get a crash with an std::string exception thrown.

Consider making intermediate datastructure that holds CXCursors only before creating CursorInfo objects.

confstr seems not to be indexed

support interpreters in Process

EventLoop quits because an of an error from select (22), invalid argument on mac

This seems to happen everytime I do rc -m on a makefile that is already indexed.

get rid of the hacks that makes it work on mac (ifdef in IndexerJob)