MaskRay
commented
6 years ago 😊
Regex based syntax highlighting Hashed Syntax Highlighting
cquery implements rainbow semantic highlighting https://github.com/cquery-project/cquery/blob/master/src/message_handler.cc EmitSemanticHighlighting
Regex based syntax highlighting is still good because files in editing may not compile and compilation has a high latency. There are some diff algorithm based heuristics to make cross references when the document differs from its indexed version.
GoTo Symbol Definition/Declaration/References - file wide and project wide
These LSP requests are most useful
textDocument/definitiontextDocument/referencesworkspace/symbol(used to approximately search a symbol defined in the workspace. It uses a fuzzy matching algorithm inspired by fzf)textDocument/documentSymbol(outline)
There are also some fancy usage and some cquery cross reference extensions (e.g. $cquery/dervided), see https://github.com/cquery-project/cquery/wiki/FAQ#definitions
Snippets
Snippets are supported via completion. The responses to textDocument/completion requests support ${2:foo} like snippets.
Semantic Autocomplete, GotTo Declaration, Diagnostics, and Documentation on hover
textDocument/definition on a definition lists its declarations while textDocument/definition on declarations or references jumps to the definition.
textDocument/hover currently displays the type signature with fully qualified names, e.g. std::vector<int> hello::foo(char a, ...).
Include Paths Autocompletion
Supported. BTW, textDocument/references on a #include directive lists all files including that file. textDocument/definition jumps to the included file.
Find Overrides of Virtual Method.
A $cquery/derived request finds derived methods/classes while $cquery/base finds base method/class. $cquery/memberHierarchy lists the type hierarchy but this is visualized in neither the VSCode plugin nor the Emacs plugin 😂
If someone is interested at cquery.el, I made an issue about generic symbol hierarchy
Documentation Generation
Comments are indexed by default. If the client supports it, textDocument/hover can display comments. There is also a documentation field in LSP CompletionItem.documentation
Debugger
I'd like to see Debug Protocol attracts more attention.
How can you integrate cquery into Sublime Text
A dedicated plugin may still be needed for some cquery extensions. See those src/messages/cquery*.cc files
The organization in the Emacs lsp ecosystem may give some insights.
https://github.com/cquery-project/emacs-cquery/ is a plugin that leverages lsp-mode (which is a generic LSP client), because semantic highlighting, cross reference extentions ($cquery/derived $cquery/base ...) are not in standard LSP.
Are there features that currently provided by RTags, which are not available with cquery at the moment?
Macros
RTags supports indexing of function calls from one-level macro expansions. See https://github.com/cquery-project/cquery/issues/331 I haven't figured out a way to do it elegantly.
Dependency
// a.h
extern int foo;
// a.cc
#include "a.h"
int foo;
// b.cc
extern int foo;Out-of-band changes to a.h (outside of the editor) and invokes $cquery/freshenIndex or workspace/didChangeWatchedFiles on a.h, the declarations of the variable foo do not update yet. But for a.cc, the declarations update. I don't know how well RTags handles this scenario.
RTags uses a C/S model while cquery is started by the editor and they communicate through stdin/stdout. Pipe (Emacs lsp-mode, LanguageClient-neovim), or Unix socket (VSCode).
RTags does not support after-change-functions through which it can update the document cross reference information without a save.
RTags supports re-read of compile_commands.json. cquery currently does not. It should be improved.
Symbol information
rtags-symbol-info stores much information retrieved from libclang, while cquery stores less (see Index{Type,Var,Func} in https://github.com/cquery-project/cquery/blob/master/src/indexer.h )
Templates
How well does RTags handle template specialization? See https://github.com/cquery-project/cquery/issues/353
RTags traverses the translation unit top-down while cquery uses higher level clang_indexTranslationUnit through declaration/reference callbacks.
There is some limitation:
// U is not indexed because it is not referenced
template<class T, class U>
void f(T a) {}No way to retrieve the location of : int32_t with libclang API, but possible with C++ EnumDecl::getIntegerTypeRange().
typedef int int32_t;
enum E : int32_t { E0, E1 };RTags has rtags-print-enum-value-at-point but cquery saves the constant value in IndexVar::def::hover and presents it for textDocument/hover requests.
typedef int int32_t;
enum E : int32_t {
E0,
E1,
};E1's incarnation in the cache file (IndexVar in IndexFile)
{
"id": 2,
"usr": 8563738222191832000,
"short_name": "E1",
"detailed_name": "E::E1",
"kind": 15,
"storage": 0,
"hover": "E::E1 = 1",
"declarations": [],
"definition_spelling": "5:3-5:5",
"definition_extent": "5:3-5:5",
"variable_type": 1,
"declaring_type": 1,
"uses": []
}How noticeable is the performance difference between RTags and cquery? Please refer to RAM usage, CPU usage, and time measurements.
I think RTags does not do well in terms of query performance. https://github.com/Andersbakken/rtags/issues/1007
# cquery cache files + copies of source files
% du -sh .vscode/cquery_cached_index
91M .vscode/cquery_cached_index
# The bin/cquery process
# VIRT 1255MB
# RES 294MB
# rtags cache files
% du -sh ~/.cache/rtags/_home_ray_Dev_Bin_radare2_
567M /home/ray/.cache/rtags/_home_ray_Dev_Bin_radare2_
# The /usr/bin/rdm process
# VIRT 345MB
# RES 67MBThe on-disk storage of cquery can also be improved.
llvm+clang+libcxx+libcxxabi takes 53 minutes to index on my laptop (X1 Carbon)
% du -sh .vscode/cquery_cached_index
630M .vscode/cquery_cached_index
% stat -c %s .vscode/cquery_cached_index/**/*.mpack | awk '{s+=$1}END{print s}'
394806885VIRT 4631MB
RES 1565MB Restart cquery to load the cache files:
38.610s ..... Applying index update
VIRT 3377MB
RES 1416MBBut you can send queries when cquery is loading the cache. https://github.com/cquery-project/cquery/wiki/Design
jacobdufault
Jo2003
papadokolos
Hello! :smile_cat:
I'm a C++ developer, and I'm using Sublime Text 3 as my primary editor. I recently discovered this exciting project, and I must begin with a big Thank You for this amazing effort.
If I wasn't clear yet, I would like to bring cquery to Sublime Text :smile:.
For this purpose, I'll write here important information which should help you decide how to approach my request.
Introduction to Sublime Text 3
Sublime Text 3 is a text editor written in C++ at its core, and is easily hackable/extendable by using its well documented python API for plugin developers.
Currently, Sublime is pretty wide spread, and has an active (and very kind :stuck_out_tongue_winking_eye: ) plugin development community. Most of the plugins are available via Package Control, the official package manager.
Sublime Text as C++ IDE
Marketing itself as a text editor, Sublime does not focus on providing IDE-like features, but rather on simplicity of use and performance. As a result, most of the C++ oriented features are coming from external plugins, similarly to vscode.
However, Sublime Text's core (which is written in C++) is very efficient, and as such, plugin developers are encouraged to use it (via the python API) in order to complete their tasks. In other words, it is better to let Sublime to do the work for you, when possible, than doing it by yourself, since it will probably be more efficient.
Furthermore, it's worth noting that everything in Sublime Text supports fuzzy searching, which is a very powerful feature, that just as well, happenes efficiently.
Currently Available features/plugins
In order to give you a complete picture, I will write both the built-in features available to a new, registered, Sublime Text user (with the newest development build), and the "most feature rich" state which combines several plugins to achieve a more C++ IDE-like experience.
Core C++ Oriented Features (Sublime Text Build 3156)
Regex based syntax highlighting
Sublime provides syntax highlighting using a custom regular expression engine, and supports both TextMate's
.tmLanguagefile format as well as as its own.sublime-syntaxfile format. The core syntax highlighting files are available at Sublime's Core Packages Repository.Hashed Syntax Highlighting
As of build 3153, Sublime is able to draw different words with different colors based on their hash:
GoTo Symbol Definition/Declaration/References - file wide and project wide
Sublime indexes the entire project internally, based on the regex syntax highlighting. After it finishes, it gives you the ability to either navigate to symbol's definition/declaration/references, and to search for symbols in the current file, and even project wide. This can be done both by keyboard shorcuts and by mouse hover.
BUT, and this is a big one, this whole thing is done non sematically! All symbols with the same name are being proposed (no context filtering, even by language!), which makes it harder to find the right symbol, and many symbols are left unrecognized due to the complex C++ syntax which can't be parsed entirely by using regex alone.
Snippets
Sublime's C++ default package provides some built in snippets for
class,if/else,ifndef,namesapce, and such.Sublime Text's API Limitations
Before I go on with external plugins, I would like to mention the limitations of Sublime's API:
HTMLandCSSformatting (minihtml). This results in one of Sublime's top weakness - the lack of a good debugger/debuggig environment.Most C++ Feature Rich Sublime Configuration - With External Plugins
Semantic Autocomplete, GotTo Declaration, Diagnostics, and Documentation on hover
Using the plugin EasyClangComplete, I have flawless semantic autocompletion of symbols (with snippets), triggered automatically when appropriate; Context aware GoTo Declaration (not definition); Real time diagnostics with inline decorations and popups; and documentation on hover, with a peek to the symbol's declaration.
This plugin is based on libclang's python bindings, and take as much information as it can from a single translation unit. That means, this plugin does not handle multiple translation units together, and does not provide project wide information.
Semantic GoTo Definition and Find All References
Using my own plugin, which is based on RTags, I implement anything that EasyClangComplete doesn't already give me. So far, I implemented GoTo Definition, Find All References, and Find Overrides of Virtual Method.
Include Paths Autocompletion
Using the plugin Include Autocomplete which is
compile_commands.jsonaware.Documentation Generation
Using the plugin DoxyDoxygen, I create and update code documentation with ease. It parses classes and function's signature and generates a documentation snippet in real time. Furthermore, it is able to update the documentation when the signature changes.
Debugger - untested
Using SublimeGDB it is possible to debug your C++ program. I havn't tried it myself yet but it seems to be a popular package that tries to make the best out of the poor GUI API that is currently available.
Note
There are more plugins and features which are relevant for a C++ developer which uses Sublime Text, but these are not related to cquery's abilities in any way, so there is no point to mention them here.
How can you integrate cquery into Sublime Text
I can think of two ways in which cquery can be integrated into Sublime Text. I would love to hear your thoughts about each of them:
Information Resources
Here are useful links to the best sources for information about Sublime Text:
Does it worth the effort? Is it better than RTags?
As you can see, I got most of the stuff figured out already. But this project got me wondering whether I should stick with RTags, or switch to cquery.
cquery seems to bring everything in one package, like RTags. It looks like it is very actively developed, and you answer to issues very quickly (as opposed to RTags' developers), which is very important for me as a user. Moreover, cquery claims to be faster than RTags, and it supports LSP.
So I would like you to answer these questions:
Thank you very much for your time, I spent the entire day to write this to you :sunglasses: Have a lovely week!