Bear

Almost the same emoticon logo too. ʕ•ᴥ•ʔ Bear vs. ʕ·ᴥ·ʔ Build EAR The compilation database tool (https://github.com/rizsotto/Bear), is extremely helpful. It got CCLS/clangd working for me over multiple in-house build systems at a vfx studio. It also is super helpful for debugging. I have used it a lot alongside a script which converts a compile_commands.json to a sequence of commands, so I can edit them individually without fiddling with the build system, and then once fixed (such as adding a flag to one TU) try to find the way to do that in the build system.

He talks about his blogging software bearblog. Bear is still here https://github.com/rizsotto/Bear and open source

There are generators for the compilation databases that work with Makefiles and other build systems, like Bear: https://github.com/rizsotto/Bear

With lsp you don't need tags. You essentially have a lsp server like clangd [0] running in the background for finding references, definitions, code completion etc. With the latest release 29.1, emacs comes with an in-built lsp client - eglot[1]. So you need to (a) Set up clangd or some other lsp server for c++. Make sure it's accessible from emacs (use something like exec-path-from-shell to get your shell paths into emacs) (b) Set up your project for clangd - this involves generating a compile_commands.json which basically lists the full compilation invocation of each and every file in your project. CMake has options to do that and likely many other build tools or maybe use something like bear[2]. (c) Enable eglot (install the package if needed on older versions of emacs) and configure appropriately. I also use projectile for project mgm

> Ultimately things like C++ code completion and intellisense require a lot of work and code to get right, and NeoVim/Vim attempts are not there yet, for example I had to give up when the only way to figure out what compilation flags a project uses meant configuring it manually. Not sure if I understand this right, but have you heard of https://github.com/rizsotto/Bear? It intercepts compilation calls to generate a clang compilation database used by C and C++ LSP implementations. This way you just have to compile the project the normal way, only wrapping the initial call (for example, to `make`) with bear: `bear make`. Once you have the database, a LSP server like ccls should work out of the box with the project.

You make your build system emit a compile-definitions.json file that has all the compiler flags for every file you compile and feed it to a language server (rtags or clangd usually, either standalone or part of another plugin like YouCompleteMe). CMake has a flag to do that as part of its configuration step (and remembers it), for other build systems you can use something like bear: https://github.com/rizsotto/Bear .

When writing Ruby C extensions, you almost inevitably need to learn to read the Ruby codebase (written in C). It helps if you can get your preferred IDE to build and understand the codebase. For people who want to use LSP + clangd to explore the Ruby codebase, I wrote up some instructions here: https://blog.jez.io/clangd-ruby/ tl;dr: Bear[1] is a tool that hijacks a process tree, looks for calls to clang, records the args it was given, and serializes those out into a compile_commands.json file that can be consumed by various clang tools, including clangd. It's really slick and in my experience Just Works (the highest praise, IMO). You can use more or less the same trick described in that post to get the Ruby C extensions you build working with LSP + clangd (no guide for this, but it should be self-evident from reading the original guide).

For C/C++ code, you can already do refactoring using clang-tidy scripts [0], or even can write custom linters using libtooling [1] and leverage the AST Matchers [2] which work at the AST level. All that's needed is a compile_commands.json file which can be easily generated via most build systems, or you can use Bear [3]/some other tool (or write a script that logs all syscalls and generate it yourself). [0] https://releases.llvm.org/12.0.0/tools/clang/tools/extra/doc... [1] https://releases.llvm.org/12.0.0/tools/clang/docs/LibTooling... [2] https://releases.llvm.org/12.0.0/tools/clang/docs/LibASTMatc... [3] https://github.com/rizsotto/Bear

It's also a tool that helps generate a JSON compilation database [0] for Clang Tooling. [0] https://github.com/rizsotto/Bear

There is also a tool called Bear which will generate compile commands from Make-based builds, in case you were wondering. I've used it with some success. https://github.com/rizsotto/Bear

https://github.com/rizsotto/Bear/blob/master/README.md Bear do something similar.

For make you could use bear (https://github.com/rizsotto/Bear). It allows you to generate a compilation database that is equivalent to that of cmake projects.