Developing a Makefile-based project? Benefit from CLion’s smart features – CLion now comes with Makefile project support out of the box. Open a folder with a top-level Makefile as a project, or directly point CLion to a Makefile in the Open dialog. The IDE will run make (with the --just-print option to avoid running an actual build), parse the output of the make command, and load the project. Check out the details, known limitations, and a long list of projects we’ve tested our approach with in this blog post.

Take a short tour

CLion now bundles CMake 3.17 and adds initial support for two of its most recent features:

1. Ninja Multi-Config: you can now pass the -G "Ninja Multi-Config" generator option to get CLion build files generated for every configuration (note that, temporarily, CLion will still use only one selected configuration for the CMake profile).
2. CMake precompiled headers: use the target_precompile_headers command to add header files to the PRECOMPILE_HEADERS and/or INTERFACE_PRECOMPILE_HEADERS properties of a target. CLion will treat such precompiled headers correctly.

Take a short tour

The Recompile single file action helps speed up the development process by quickly checking local changes, and it is now available for Ninja and other generators used in CMake and supported in CLion.

Thanks to an important bug fix, CLion can now build multiple independent projects in parallel, without them blocking each other from starting.

Pointers that point to invalid data lead to run-time issues. Typical cases are double-free and use-after-free combinations. CLion now catches such dangling pointers if they appear in the local scope, no pointer arithmetic is involved, and macros are not preventing CLion from performing the analysis.

This CLion inspection detects situations where a loop condition is not updated inside the loop. It’s similar to Clang-Tidy’s clang-tidy:bugprone-infinite-loop but works for loops with exit points and can handle cases with lambdas or references.

Last but not least, we’ve introduced a new Inspection Widget. It displays the number of warnings and errors in the current file and lets you navigate between them with ease. You can also configure the highlighting level (just like you could previously with the so-called Hector icon).

If you click on the Inspection Widget, the Problems View tool window will open (View | Tool Window | Problems). It shows the list of warnings and errors in the current file, helps you navigate to the place in your code where the problem was encountered, and allows you to fix the issues by invoking the Alt+Enter shortcut right from the tool window.

Newly added keywords are supported by CLion 2020.2 in code highlighting and completion:

• char8_t
• consteval and constinit
• co_await, co_return, and co_yield

The C++20 explicit(bool) construct is now highlighted correctly. It’s also equipped with name hints for condition arguments and is supported in navigation and refactoring.

A new inspection for code that uses Concepts has been added. It suggests constraining local variables declared as auto if the result of a constrained function call is assigned to them.

The GTEST_SKIP() macro in Google Test provides the ability to skip tests at runtime. This is now supported by CLion.

CLion 2020.2 improves the user experience by adding coverage flags automatically when you click the Run with Coverage button. Now, if your currently selected CMake profile doesn’t include compiler options for coverage, CLion will search for a CMake profile (and create one if not found) with the coverage flags passed via CMAKE_CXX_FLAGS and CMAKE_C_FLAGS.

PlatformIO project configuration files are now highlighted properly, so you can read and update them more easily.

CLion now automatically creates CMake Profiles for the CMAKE_CONFIGURATION_TYPES entries in the PlatformIO CMake project.

If you develop with the WSL2 toolchains and use Git on WSL2, you will now benefit from CLion switching between Git executables depending on the project location. It will auto-detect the Git executable from WSL2 for projects opened from there (via \\wsl$ path) and switch all Git-related features to work with it.

The Go to Declaration or Usages action (Ctrl+Click / Ctrl+B) behaves differently depending on the case and the IDE settings:

• When invoked on a symbol usage, it navigates to that usage’s declaration.
• When invoked on a declaration, it shows the list of that declaration’s usages.
• When invoked on a definition, it shows the associated declaration or usages. This depends on the settings in Settings | Editor | General | Go to Declaration or Usages.

In version 0.3 of the plugin, the new engine for macro expansion, which until now had been experimental, is enabled by default. This engine handles macro-generated impl blocks and module declarations, providing code insight for the entirety of your code, including crates like tokio and async-std. Learn more in this blog post.

Another major update is the introduction of initial debugger support for Rust’s MSVC toolchain. Now you can use the LLDB-based debugger bundled in CLion for the Visual Studio toolchain to debug Rust code built on Windows using Rust’s MSVC.

Other enhancements include new refactorings (Move for files and top-level items and Introduce Constant), initial support for or_patterns, error highlighting in format literals inside macros like println!, rendering for documentation in the editor, inlay hints for chain method calls, and improvements to the debugger workflow in IntelliJ IDEA.

Remote GDB Server and Embedded GDB Server configurations now work with custom targets. These configurations, which previously only worked with CMake targets, allow you to debug your application on a remote host or on the microcontroller from the CLion instance running on your local machine.

If you have already created these configurations, CLion 2020.1 will store previous Run/Debug Configuration settings in the projectFilesBackup directory in the project folder and will notify you about this.

If you need to redirect input from a file to the stdin of your application, you can now do that. Use a new field in the configuration called Redirect input from. Enter:

• A relative path (CLion will prepend with the Working directory path).
• An absolute path (will be remapped for remote configurations).
• Or macros (like FilePrompt).

Now, when you first open a project with a .clang-format config file in the project root, CLion will detect it and switch to ClangFormat for you automatically.

If you enable ClangFormat on a project that doesn't have a .clang-format config file, CLion will suggest creating one for you.

When calling the Change Signature refactoring (Ctrl+F6), CLion updates all the usages of the function. A new Default value field in the Change Signature dialog offers the ability to specify the value of the parameter to be used across all usages. Keep it blank to use the default value type as before.

The same logic and a new Default value field apply to the Create Parameter From Usage quick-fix and the Add Parameter to Constructor intention.

Quick Documentation – a universal tool to preview documentation and get information about function signature, inferred types, and macro replacement – is now available on mouseover.

It can be controlled by the setting Show quick documentation on mouse move in Settings | Editor | Code Editing.

An updated tool window provides more space for the list of modified files and the diff. It also lets you add changes to a commit when they are ready, compose a commit message iteratively, and choose which of the staged changes go into which commit.

The new UI is enabled by default for new users; existing users can switch to it in Settings | Version Control | Commit.

With improvements to LLDB support, IntelliJ Rust now properly renders enums and primitive types, and it also shows demangled function names in the call stack.

Another major update that has landed in the plugin is REPL integration. Invoke the console from Tools | Rust REPL and use it for prototyping and checking your code line by line. The integration provides syntax highlighting and code completion, along with some handy console actions: command history, soft wrap, quick scroll to end, and others.

On the language-support side, IntelliJ Rust now handles impl blocks for type aliases. Taking performance into account, we've only enabled this feature for types with a limited number of aliases.

Other enhancements include highlighting for unused local variables, fixes in cfg attribute support, and the new Lift return inspection.

Support for the new CMake File API lets CLion 2019.3 enable various CMake generators (requires CMake 3.15 or higher). Previously, only Makefiles were supported, now users can select Ninja, Xcode, Visual Studio, etc.

This works for all platforms, in remote mode, and with WSL.

If you want to customize the GDB/LLDB debugger behavior on a particular project, you can now do so in CLion, as it supports reading the settings file from the project root directory.

Note that to enable this behavior, you have to explicitly allow it in your home file. See how to do this for LLDB and GDB.

One of the biggest features coming in C++20 is definitely Concepts. By collaborating with the author of Concepts support in Clang, we’ve brought Concepts to CLion 2019.3. The support covers not only code parsing and highlighting (which is done by the Clangd-based language engine), but also comes with:

• The Unused Concept inspection.
• Code completion including completion for types constrained by std::is_base_of<MyBase, T> and std::is_same<Other, T>.
• The Rename refactoring.
• Go to Definition and Find Usages.

If you’ve ever asked the question, “Was this statement executed during the configuration run?”, that means you are looking for statements coverage measuring for your code. CLion 2019.3 has it thanks to the integration with llvm-cov/gcov tools.

You can get it for unit tests run or a regular configuration run. The results are available in the Coverage tool window or via a color indication in the editor’s left gutter.

One of the biggest updates for IntelliJ Rust is the initial support of cfg attributes. Now, the conditionally disabled blocks are grayed-out and excluded from resolve and code analysis. Among the supported cfg options are unix, windows, and target_os.

The widely used quick-fix, Auto-import for unresolved symbols, now works automatically when you call Implement members, Specify type explicitly, Add remaining patterns, and other code generation actions.

Other changes include Code Coverage for your Rust code, which has been a part of the plugin for a few releases already, handy interactive inlays for type hints, and include! macro support.