CleanMyPC

What's new in this version:

Key updates:
- Our support for remote development (Beta) lets software engineers connect to a remote machine, deploy an IDE backend on it, and work on a project located there as if it were on their local machine. You can access this feature from the IntelliJ IDEA Welcome screen or by downloading JetBrains Gateway from the Toolbox App.
- There is a new, faster way to diagnose and fix issues with your IDE – the Repair IDE… action, which is available in the File menu.
- The Smart Step Into action now works on Kotlin code. It allows you to debug an expression with chained method calls and lambdas, highlighting the methods and lambdas you can step into.
- The debugger can detect Kotlin inline functions and display inline function calls in the stack trace panel.
- The new Constant conditionsinspection for Kotlin helps IntelliJ IDEA report non-trivial conditions and values that are statically known to be always true, false, null, or zero. It works the same as the similar inspection for Java.

Editor:
- It is possible to change the font size in all open tabs simultaneously with ⌘+mouse wheel on macOS or Ctrl+mouse wheel on Windows and Linux.
- You can now insert tables in your Markdown files with ease.
- Working with editor tabs just got easier. Just click the three dots in the right-hand corner of the tab pane to access all the tab actions.
- The intention preview now works for more intention actions and quick-fixes in Kotlin, and it shows the HTML descriptions of the intention actions for which previews aren’t supported.
- User experience:
- When you use the F3 shortcut on macOS or F11 on Windows and Linux, your files, folders, and classes will appear in the new Bookmarks tool window. You can find more details about this feature in this blog post.
- We’ve made it possible to split the Run tool window with tabs. This allows you to run several configurations simultaneously and see all of the results.
- When searching for actions, Search Everywhere in IntelliJ IDEA uses machine learning to rank the results.
- The reworked Empty Project node in the New Project wizard window allows you to create a basic project for working with separate files of different types, where you can also add Java and Kotlin classes.
- The new Multi-Module Project node lets you create a project with a complex structure from scratch.
- By default, IntelliJ IDEA now uses top-level hierarchy methods as targets when you search for usages of a method implementation via⌥ F7 on macOS or Alt+F7 on Windows and Linux.
- The Show Usages dialog now includes a source code preview per found usage, the ability to change the search scope, and the option to see the type of code element you are searching for and the number of usages found.

Accessibility updates:
- When the screen reader is active, the IDE no longer shows the tool window widget popup and the quick documentation popup that used to appear on mouse hover.
- We’ve also fixed an issue with calling the Go to Declaration dialog.
- The accessibility support on macOS has also been improved. We’ve resolved several issues with the voiceover focus and made it possible for screen readers to detect list items in the New Project wizard when you create projects.
- To minimize potential distractions while you’re coding, we’ve decreased the number of help tooltips that play sounds.

Java:
- IntelliJ IDEA has added a new inspection “Non-safe string passed to a safe method”, which helps avoid passing insecure data to secure methods in projects that use the org.checkerframework.checker.tainting.qual annotations. Problems that could be detected by this inspection include SQL injections and XSS flaws.
- We’ve added two new inspections that can help you to simplify your code. The first suggests that you replace collect(toList()) with .toList(). You can use it with Java versions 16 and up. The other inspection prompts you to replace collection.addAll(List.of(“x”)) with collection.add(x), and map.putAll(Map.of(“a”, “b”)) with map.put(“a”, “b”).
- The settings for introducing a local variable in Java no longer appear in a pop-up, which used to hide the code you were writing. You can now access them via the gear icon next to a variable or by using the⌥+⇧ +O shortcut on macOS or Alt+Shift+O on Windows.
- When you invoke the Introduce parameterrefactoring, the IDE asks where you want to replace occurrences. After you make this selection, a gear icon will appear, allowing you to configure more settings for the refactoring.
- You can define custom classpaths in the Run/Debug Configurations dialog on a per-config basis by selecting Modify options | Modify classpath.

Kotlin:
- A new refactoring has been introduced that lets you extract constants in Kotlin.
- The Possibly blocking call in non-blocking context inspection is now customizable, covers more cases, and also offers a quick-fix.
- We’ve added inline hints that use plain mathematical signs to explain what the words or symbols in ranges do.
- We’ve reworked the layout of the New Project wizard by adding tooltips for all of the fields, removing some of the unpopular templates and adding a new one that lets you create a Compose Web Application, and simplifying the project setup step.
- JavaScript:
- Update your npm packages to the latest version right from the editor.
- The way code completion works in HTML has been improved. Whenever you type a tag name or an abbreviation in the editor or invoke code completion, IntelliJ IDEA will immediately show you relevant suggestions.

Scala:
- A big focus of this release has been Scala 3 support. We’ve added highlighting, navigation, and autocompletion for end markers, the given, using, and exportkeywords, soft keywords, and quiet syntax. In addition, the TASTy reader can now parse package objects, as well as variance and bounds in higher-kinded types.
- Scala 3/Scala 2 cross-compiled projects can be opened as Scala 2 projects.
- The Scala plugin now supports data flow analysis, which can help you detect programming errors more easily.
- The Scala compiler options can now be autocompleted, and you can even see Quick Documentation for each of them.
- Inlay hints can be used for ranges in Scala.

SSH:
- You can specify an HTTP or SOCKS proxy server for your SSH configuration in Preferences/Settings | Tools | SSH Configurations.

Profiler:
- The Windows version of IntelliJ IDEA Ultimate supports Async Profiler 2.0 out of the box.
- Snapshots can be compared to check whether the changes made worked for the program or caused a regression.

Build tools:
- Maven configurations have had a significant redesign. The key parameters are all grouped on one screen, while additional parameters are available via the Modify options.
- It is now possible to configure the Maven settings for each project in the .mvn/maven.config file in Preferences/ Settings | Build, Execution, Deployment | Maven by selecting Use settings from .mvn/maven.config.

Version control:
- The Checkout and Rebase onto Current action can be used for remote branches.
- The way the settings in Preferences/Settings | Version Control are structured has been improved, and some of the critical configurations are now more discoverable.
- The difference between commits is now shown in a separate Changes tool window located to the left of the editor.
- A new Push All up to Here action allows you to push only the commits you are confident about and leave the rest for later.
- The new Align Changes Highlighting option makes the diff easier to read, as the unchanged lines are aligned so that they are displayed next to each other. This helps you see the code that has been added or removed more clearly.

Terminal:
- New support for the ConPTY API on Windows addresses several issues with the old implementation and includes support for 24-bit colors in the terminal.
- Newly added typeahead support in the terminal predicts text modifications and instantly displays them in light gray.

Debugger:
- The Evaluate field is now accessible right in the Debug tool window, making the most convenient way to evaluate expressions more obvious.
- Frameworks and technologies:
- IntelliJ IDEA’s HTTP client provides essential support for gRPC requests, including code completion and the ability to generate gRPC requests in the HTTP client.
- When testing streaming applications in IntelliJ IDEA, you no longer need to wait for a stream to end, because the HTTP client will display the output on the fly.
- The HTTP client can detect images in responses and display previews of them in the response console.
- In the HTTP client, it is possible to redirect output to a custom file or directory with the >> and >>! operators.
- Request identifiers can be added either as comments via @name or as text in the first separator (###).
- Qute templates provide support for your Quarkus projects.
- IntelliJ IDEA can detect when your OpenAPI specifications are located in several files and linked via $ref, and it will provide completion for them.
- When adding ‘org.jetbrains:annotations:22.0.0’ to the project dependencies, you can annotate your classes and methods as @Blocking or @NonBlocking. This allows the IDE to detect blocking calls in non-blocking contexts, such as Kotlin coroutines or reactive code with Project Reactor, RxJava, or SmallRye Mutiny.
- Blocking code detection in Spring and Java EE has been improved.
- The Run/Debug Configurations dialog for Spring Bootprojects has been reworked so the key settings are now located on one screen and more parameters are available via Modify Options.
- IntelliJ IDEA provides code completion in additional configuration files (properties or .yaml files) when a spring.config.import key is used to reference another file.
- For Spring Boot projects, the IDE now supports code completion and find usages for references to application.yaml from @Value, @Scheduled, and Environment.getProperty().
- Query method completion now works for queries declared as @NamedQuery in Spring Data JPA projects. You can also navigate to the definition of a @NamedQuery via the gutter icon.
- All CDI inspections can be used in Kotlin files, and the CDI gutter icons are available in them as well. These icons allow you to quickly navigate to injection points or injection candidates, bean makers, disposer methods, and events.
- All the processes for UML class diagrams are faster, both in Java and Kotlin. Other notable changes include a new grid, member highlighting, and a quick documentation preview pop-up.

Space integration:
- You can now submit merge requests and create code reviews for your projects in Space.
- IntelliJ IDEA marks all the files you haven’t yet revised with blue dots so you don’t miss any critical changes when performing a code review.

Database tools:
- The ability to display an Aggregate view for a range of cells was added, which will help you manage your data and spare you from having to write additional queries.
- The workflow for generating a DDL data source based on a real one is now fully supported. There is a new tab in the data configuration properties, DDL mappings, where you can define which real data source is mapped to each DDL data source.
- The new Database diff window is available from the context menu. It has a better UI that clearly shows what result you’ll get after you perform the synchronization in the right-hand pane.
- We’ve introduced three levels of introspection for Oracle databases, which vary from the fastest to the slowest. Use the context menu to switch the introspection level as appropriate.

Kubernetes:
- Formatting for Helm templates has been significantly improved.
- It is now much easier to work with code that contains Go template inclusions because we’ve added highlighting for the following block elements in Helm templates: if, else, range, with, and define.
- IntelliJ IDEA now supports automatic code injections of various languages in ConfigMap resources for keys with extensions like .yaml, .json, .properties, and so on.
- There is a new button in the Services tool window that allows you to rerun your last Helm command.

Docker:
- In Preferences/Settings | Build, Execution, Deployment, you can select the Minikube radio button to connect to a Docker daemon from Minikube.
- All available registries are displayed in separate nodes in the Services tool window. Also, support for GitLab (registry.gitlab.com) and JetBrains Space (<username>.registry.jetbrains.space) was added. For more details on the changes in the Docker registries, check out this blog post.
- Connecting to Docker now takes less time because you can simply double-click on the necessary node or use the new shortcut – ⌘+Enter on macOS or Ctrl+Enter on Windows and Linux. The Start container action can also be invoked with this shortcut.
- When you right-click on the Networks, Volumes, Containers, or Images node, you can select the new Clean up action, and the IDE will delete unused objects.
- We’ve added support for Compose V2, which allows you to run Docker Compose commands as docker compose instead of docker-compose (with a dash).
- The new Layers tab in the Services tool window allows you to track all the commands applied to images.
- In the Services tool window, you can right-click on the container and select Image | Save as a new Image to push a locally-stored preconfigured container so you can use it remotely later.
- Podman is now supported as an alternative way to manage pods, containers, and images. Before using Podman in the IDE, you’ll need to configure a connection.

QA tools:
- A huge update brought support for UI test automation in Selenium – the visual editor can now help you maintain existing page object classes.
- Support for multilevel test runs has been implemented. You can now create multiple child test runs for specific functionality domains or types of testing. Each parent test run aggregates the results of the child test runs and provides summary statistics from all sub-related test runs.
- The Test Management plugin now supports a rich-formatting description. The test case description or steps have always been written in Markdown, but now the formatting can be displayed and drawn directly in the TMS preview window.
- The newest plugin from the Test Automation Kit has received a few minor bug fixes, as well as a helpful feature in multiple data generator settings. Now you can modify prefixes, suffixes, and delimiters with a multi-line definition.

Quality enhancements:
- Fixed the Hierarchy tool window so it correctly displays the usages of an interface method that has at least one implementation
- Fixed the causes of several IDE crashes on Linux
- Fixed recurring indexing on every startup if the IDE was closed due to OS shutdown
- Fixed the Maven Wrapper feature. The IDE now automatically downloads Maven Wrapper (if you haven’t downloaded it yet) and uses it for Maven goal execution. Additionally, the IDE remains responsive when downloading Maven Wrapper upon opening a project and displays the download progress
- If you use the font zoom feature, it is now applied to all open files, not just the current one. You can activate this new option by selecting the All editors radio button in the Mouse control section in Preferences/Settings | Editor | General
- Fixed the autosave feature so it works as expected even with open pop-ups
- Fixed the WSL 2 error that would occur when trying to reload all Maven projects or execute a Maven goal
- Fixed the error causing exploded WAR not to be generated when the Delegate IDE build/run actions for Gradle were enabled
- Fixed the behavior of the Stop button. When you stop the WildFly Run Configuration, the Terminate Batch Job prompt no longer appears
- Fixed the UI freezes when browsing in the file chooser dialog on macOS
- Fixed the error causing the IDE not to recognize Maven multi-module dependencies in WSL 2
- Fixed the modified .vmoptions files so they will be properly updated during IntelliJ IDEA version upgrades
- It is now possible to disable list editing in Markdown. To do so, go to Preferences/Settings | Languages & Frameworks | Markdown and deselect the Automatic assistance in the editor checkbox
- Fixed the Welcome screen; the project list is now in focus
- Focus no longer shifts to the File menu when F10 is pressed during debugging
- Fixed the Maven resources compiler, which was returning a Failed to copy error when building a project inside WSL 2
- Fixed the tabs closing incorrectly when multiple tabs are open
- Fixed the File mask field in the Find in File dialog. The list is now displayed correctly
- Fixed the IDE’s behavior when double-clicking on a window’s title bar on macOS
- Fixed the spellchecker. It now recognizes words with apostrophes
- Fixed the Diff tab so it shows the correct file name when comparing files
- Fixed the problem causing the navigation bar not to stay disabled when working in the distraction-free mode
- Fixed the ability to add external tools to the Quick List
- Fixed the annotation panel so it displays the same theme as applied to the whole IDE
- Fixed the formatting for the YAML code formatter
- Fixed the VM options so they stay applied once configured
- Fixed the bug causing incorrect environment variables to appear in the ProxyCommand when you start the IDE from the JetBrains Toolbox App
- Fixed the new Maven Run Configuration so that it is compatible with previous versions of the IDE
- Added the ability to debug various Gradle scripts

Other:
- We’ve added support for Android Studio Arctic Fox 2020.3.1
- IntelliJ IDEA now has support for Groovy 4, including full-fledged code insight, functioning inspections, and intention actions. Additional features, such as switch expressions and sealed types, are supported as well.