IntelliJ IDEA 2021.3

Integriert die Unterstützung für die dezentrale Entwicklung und führt eine neue Methode zur Behandlung von IDE-Problemen ein.
Dezember 1, 2021
Neue Version

Funktionen

  • Key updates
    • Remote development (Beta) - IntelliJ IDEA Ultimate now supports a Beta version of the Remote Development workflow. It allows you to connect to a remote machine running IntelliJ IDEA’s backend from anywhere in the world. All the processing happens on that powerful remote machine, and you can work on your project as seamlessly as if it were on your local one. This functionality can be initiated from IntelliJ IDEA’s Welcome screen or from a new application called JetBrains Gateway, which is available in the Toolbox app. What’s more, you can create, prebuild, share, reproduce, hibernate, and manage dev environments with Space - a unified platform for the entire software development pipeline.
    • Troubleshooting IDE issues - IntelliJ IDEA 2021.3 brings a new, faster way to diagnose and fix issues that are causing your IDE to not work properly. If your IDE isn’t working properly, invoke the new Repair IDE... action from the File menu. It will guide you through a sequence of steps to troubleshoot some of the most common problems.
    • Constant conditions inspection for Kotlin - Added the new Constant conditions inspection, which 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 way as the similar inspection for Java, and it supports most of the same checks.
    • Debugger updates for Kotlin:
      • Smart Step Into - When you want to debug an expression with chained method calls and lambdas, the Step Into action gives you the functionality of Smart Step Into by default. It highlights the methods and lambdas you can step into.
      • Inline stack frames - The debugger can now detect Kotlin inline functions and display inline function calls in the stack trace panel. You can navigate to these calls, and you can also inspect and evaluate the variables of each frame.
  • Editor
    • Change font size in all the tabs - Added the ability to change the font size in all open tabs simultaneously with ⌘+mouse wheel on Apple macOS or Ctrl+mouse wheel on Microsoft Windows and Linux.
    • Improved intention preview:
      • IntelliJ IDEA has a helpful option that allows you to preview the results of intention actions and quick-fixes before applying them to your code.
      • In IntelliJ IDEA 2021.3, it works for more intention actions and quick-fixes in Kotlin, and the “Preview isn't available” message has been replaced with more informative HTML descriptions of the intention actions that aren’t supported. What’s more, for an action that modifies several files, the preview displays part of a possible outcome. This partial outcome should be enough to give you a general idea of what the action will change.
    • Improved Markdown support - Tables can now be created with ease. Simply invoke the context menu and select Insert | Table. You can select the preferred size using the mouse hover action or the keyboard. The cell width in the table will be adjusted as you type. You can edit the table content using the floating toolbars. To create a new row you can use Shift+Enter, and Tab to navigate to the next cell.
  • User Experience
    • New Bookmarks tool window - Added the new Bookmarks tool window that is destined to replace a similar instance – Favorites.
      • From now on, you can simply use the F3 shortcut on macOS or F11 on Windows and Linux to mark your files, folders, and classes as important.
      • When you add a bookmark, by default IntelliJ IDEA puts it in the node named after your project in the Bookmarks tool window.
      • Every time you add a new bookmark, it will appear at the top of the list inside this node.
      • You can sort your bookmarks by type using the Sort Groups and Bookmarks option in the tool window’s settings.
      • You can also create new nodes and drag and drop items in them.
    • Ability to split the Run tool window - Added the ability to split the Run tool window with tabs. This allows you to run several configurations simultaneously and see all of the results. To split the window, drag the tab you want to see to the highlighted area inside the Run tool window and drop it there. To unsplit the window again, right-click the top pane and select Unsplit from the context menu.
    • ML-based search for actions in Search Everywhere - When searching for actions, Search Everywhere in IntelliJ IDEA is now powered by machine learning by default. An ML-based formula has been trained that takes into account:
      • The specific user’s action usage history.
      • Action usage frequencies across the whole user base.
      • The lengths of the search query, the action’s name, and so on.
    • Improved Find Usages - When you search for usages of a method implementation via ⌥F7 on macOS or Alt+F7 on Windows and Linux, the IDE no longer asks whether you want to find usages of the base method in a pop-up. Instead, IntelliJ IDEA will use top-level hierarchy methods as targets for your search by default. If you want to change this behavior, deselect the Search for base method usages checkbox in the Find Usages tool window settings, which you can access by clicking the gear icon.
    • Reworked Show Usages - The Show Usages dialog has received several useful new features:
      • Introduced the source code preview per found usage, which you can see by clicking the square icon in the top toolbar pane.
      • Another update lets you change the scope of your search with the new drop-down list located next to the Preview icon.
      • The window’s title bar now shows the type of code element you are searching for and the number of usages found.
      • Another minor yet very convenient update allows you to set the dialog width, which the IDE will retain the next time you invoke it.
    • Reworked Empty Project and new Multi-Module Project nodes:
      • You can now select the Empty Project node to create a basic project for working with separate files of different types and adding Java and Kotlin classes.
      • The IDE will automatically configure the project so that you can compile it if any Java or Kotlin classes are present.
      • The new Multi-Module Project node lets you create a project with a complex structure from scratch. Once the project is created, the Project Structure dialog will open, and you’ll be able to add various modules.
    • Accessibility updates - IntelliJ IDEA 2021.3 addresses some accessibility issues to make working with the screen reader more comfortable:
      • The tool window widget pop-up has been disabled and the quick documentation pop-up that used to appear on mouse hover.
      • Fixed an issue with calling the Go to Declaration dialog.
      • The accessibility support on macOS has also been improved.
      • Resolved several issues with the voiceover focus and made it possible for screen readers to detect the list items in the New Project wizard when you create projects.
      • To minimize distractions while you're coding, the number of help tooltips that play sounds has been decreased.
  • Java
    • Inspection for tracking unsafe strings - IntelliJ IDEA now warns you about hazards such as SQL injection and XSS flaws, sensitive data leaks, and insecure deserialization. It also prevents you from passing insecure data to secure methods. These additional warnings are provided by the new Non-safe string is passed to a safe method inspection. For this inspection to work, you need to annotate strings as @Untainted (“safe”) or @Tainted (“unsafe”). These annotations will become valid when you add the org.checkerframework.​checker.​tainting.​qual dependency.
    • Other new Java inspections - Added two inspections that can help you to simplify your code. The first one suggests that you replace collect(toList()) with .toList(). You can use it with Java versions 16 and up. Another 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").
    • Improved refactorings:
      • When you introduce a local variable in Java, the settings that are applicable to it no longer appear in a pop-up, which used to cover the code you were writing. Instead, you can access these options by clicking the gear icon next to a variable or by using the ⌥⇧O shortcut on macOS or Alt+Shift+O on Windows.
      • Improved the Introduce parameter refactoring. When you invoke this refactoring, with ⌥⌘P on macOS or Ctrl+Alt+P on Windows and Linux, the IDE asks where you want to replace occurrences. After you make this selection, a gear icon will appear, and clicking on it will allow you to configure more settings for the refactoring.
    • Customizable classpath in Run/Debug Configurations - Sometimes you may need to define custom classpaths in the Run/Debug Configurations dialog on a per-config basis. Starting from this version, it is possible to do so by selecting Modify options | Modify classpath.
  • Kotlin
    • Extract constant refactoring - Introduced a new refactoring that lets you extract constants in Kotlin. To use it, put the caret on a string and press ⌥⌘C on macOS or Ctrl+Alt+C on Windows and Linux.
    • Improved Possibly blocking call in non-blocking context inspection - The Possibly blocking call in non-blocking context inspection warns you if you use a coroutine in the wrong context. In this release, the inspection works not only as a warning but also as a context-dependent quick-fix. This inspection now covers more cases, and you can customize it, so it works better in your particular environment.
    • Inline hints for ranges - Sometimes it can be difficult to understand the various ways to declare the ranges that Kotlin supports. To make it a little easier, inline hints have been added that explain with plain mathematical signs what the words or symbols in the ranges mean. If you don’t need this feature, you can easily disable it by right-clicking on a hint and selecting Disable ‘Ranges’ hints type.
    • Better New Project wizard - Reworked the layout of the New Project wizard by adding tooltips for all of the fields, so you can easily understand what info they require. The templates section has received an update as well – Some of the unpopular templates have been removed and a new one has been added that lets you create a Compose Web Application. The project set up step has become much simpler. You now only need to fill in the basic fields.
  • Scala
    • Scala 3 support improvements:
      • Added highlighting, navigation, and autocomplete for end markers.
      • There's now autocomplete for given, using, and export keywords, soft keywords, and the quiet syntax.
      • The TASTy reader can now parse package objects, as well as variance and bounds in higher-kinded types.
      • The highlighting of lexer and parser errors is now significantly faster.
      • There are more inspections that are compatible with Scala 3.
      • Improved the resolve of given imports and supported final top-level members and abstract lazy vals.
    • An option to open Scala 3 / Scala 2 cross-compiled projects as Scala 2 - Many projects that should be compiled for both Scala 2 and Scala 3 are modeled as Scala 3 projects cross-compiled for Scala 2, even though technically they are Scala 2 projects. Opening such projects as Scala 2 allows the IDE to use the correct Scala version, and is more reliable.
    • Data flow analysis for Scala - The Scala plugin now supports data flow analysis, which can help you detect programming errors more easily.
    • Autocomplete for Scala compiler options - There are many different options in the Scala compiler, those options vary depending on the Scala version in use. You can now autocomplete the applicable options and even see Quick Documentation for each of them.
    • Inlay hints for ranges - Added inlay hints for ranges.
  • JavaScript
    • New inspection for updating dependencies - This release allows you to update your npm packages to the latest version right from the editor. Open your package.json file, place the caret on the package version you want to update, and then press ⌥⏎ on macOS or Alt+Enter on Windows and Linux and select Update ‘package name’ to the latest version. A quick-fix will also be shown when you hover over the package version.
    • Improved code completion in HTML - Improved the way code completion works in HTML. Whenever you type a tag name or an abbreviation in the editor, or invoke code completion, IntelliJ IDEA will show you relevant suggestions right away. Previously, it would only show them if you typed < first. Additionally, code completion for character entity references should now work better.
  • SSH
    • Proxy support for SSH connections - This new feature allows you to specify an HTTP or SOCKS proxy server for your SSH configuration in Preferences/Settings | Tools | SSH Configurations. Under the new HTTP/SOCKS section, you can select the proxy type, enter a hostname and a port, and apply authentication with a username and password, if necessary. It is also possible to sync your SSH proxy settings with the global IDE ones. To do so, select the Use global IDE proxy settings checkbox.
  • Profiler
    • Compare .jfr snapshots - It is now easy to check whether the changes you’ve made worked for your program or caused a regression. To do so, just open two snapshots that you want to compare in the Profiler tool window. In the most recent snapshot, click the diff icon and select the snapshot you’ll use as the baseline. The IDE will display the result in the form of a flame graph, call tree, or method list.
    • Support for Async Profiler 2.0 on Windows - Starting from v2021.3, the Windows version supports Async Profiler 2.0 out of the box as well. This support provides a smoother profiling experience and also improves the way native functions are displayed in snapshots.
  • Build tools
    • Redesigned Maven configurations - This release takes some steps toward improving the Run/Debug configurations, and this time, Maven configurations have received a significant redesign. The key parameters are all grouped on one screen, while additional options are available via Modify options.
    • Support for .mvn/maven.config - If you want to configure the Maven settings for each project in the .mvn/maven.config file, go to Preferences/Settings | Build, Execution, Deployment | Maven and select Use settings from .mvn/maven.config at the bottom of the screen. Please keep in mind that the settings from this file override the standard Maven UI settings.
  • Version control
    • Checkout and Rebase onto Current for remote branches - With the Checkout and Rebase onto Current action, you can check out the selected branch and rebase it on top of a branch that is currently checked out. Previously, this action was available for local branches only. Now you can use it for remote branches as well.
    • Reorganized VCS settings - Improved the way the settings in Preferences/Settings | Version Control are structured, and made some of the critical configurations there more discoverable. The Version Control node now serves as the starting point for navigation, with links to all the available settings. If you go to the Git node from there, you’ll notice that all the settings have been divided into sections that account for the most important processes: Commit, Push, and Update. The parameters inside these sections are now organized more logically. A separate node for Directory mappings has been added, and the background operations are now switched on by default. The Background node no longer exists.
    • New Changes tool window - Starting from this release, your IDE shows the difference between commits in a separate Changes tool window located to the left of the editor.
    • New Push All up to Here action - Added a new action that allows you to push only the commits you are confident about and leave the rest for later. It allows you to push commits up to the one you have selected in the Log tab of the Git tool window. To use it, pick the commit you want to stop at, right-click on it to call the context menu, and select the new Push All up to Here action.
    • Align Changes Highlighting - Added the new Align Changes Highlighting option to the Diff screen settings that can be found under the gear icon. This feature makes the Diff easier to read, especially when there are complex modifications, because it aligns the unchanged lines so that they are displayed next to each other. This helps you see the code that has been added or removed more clearly.
  • Terminal
    • ConPTY support on Windows - Added support for the new ConPTY API on Windows. It addresses several issues users were having with the old implementation, which was based on winpty, and adds support for 24-bit colors in the terminal.
    • Typeahead support - The newly added typeahead support in the IntelliJ IDEA terminal predicts text modifications and instantly displays them in light grey. This feature allows you to type in the terminal equally fast on both a local or remote machine.
  • Debugger
    • Evaluate expressions from the debugger - Improved the discoverability of the Evaluate feature. Previously, when users needed to evaluate something, many of them resorted to using watches. They just created a watch and then removed it, instead of using the Evaluate dialog. The Evaluate field is now accessible right in the Debug tool window, making the most convenient way to evaluate expressions more obvious.
  • Frameworks & Technologies
    • gRPC requests in the HTTP client - IntelliJ IDEA’s HTTP client provides basic support for gRPC requests. When you type the GRPC keyword to start your request, the HTTP client offers code completion. Your IDE prompts you about all known gRPC services, unary and server-streaming methods of a particular server, and, most importantly, fields of the request body. Another new feature allows you to generate a gRPC request in the HTTP client. To do so, just click on the gutter icons in your .proto files.
    • Binary responses in the HTTP client - The HTTP client can now detect images in responses and display previews of them in the response console.
    • Support for text streams and JSON streams 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. This is now possible because support has been added for the following content types: text/event-stream, application/stream+JSON, and application/x-ndjson. You will also be notified when a stream ends.
    • Output redirection to custom file or directory in the HTTP client - In the HTTP client, it is now possible to redirect output to a custom file or directory. You can use two operators for forced and soft redirects:
      • The >> operator always creates a new file, adding an -n suffix to the file name if the requested file name already exists.
      • The >>! operator rewrites the file if it already exists.
    • Support for HTTP request identifiers - You can now add request identifiers either as comments via @name or as text in the first separator (###). The IDE understands these identifiers and allows you to invoke requests by them from the Services tool window, as well as from the Run Configuration, Run Anything, and Search Everywhere dialogs.
    • Qute template language support - Qute is now among the supported template languages. This means that IntelliJ IDEA provides code highlighting, autocompletion, and other useful features to help you develop templates for your Quarkus project.
    • References resolve and completion from secondary specification files - IntelliJ IDEA can now detect when your OpenAPI specifications are located in several files and linked via $ref, and it will provide completion.
    • New Blocking and Non-Blocking annotations for reactive code - 2 additions have been made to the JetBrains annotation collection. Once you add 'org.jetbrains:annotations:23.0.0' to your project dependencies, you can annotate your classes and methods as @Blocking or @NonBlocking. This will make it possible for the IDE to detect blocking calls in non-blocking contexts, such as Kotlin coroutines or reactive code with Project Reactor, RxJava, and SmallRye Mutiny. The IDE now automatically supports the corresponding annotations from Micronaut and SmallRye Mutiny as well.
    • Improved blocking code detection in Spring and Java EE - IntelliJ IDEA now detects more cases of blocking code in Spring and Java EE, including Spring Data’s JpaRepository and CrudRepository, RestTemplate and JdbcTemplate, Spring Feign interface methods, JPA EntityManager calls, and any methods and classes annotated as @Transactional.
    • Revamped Spring Boot Configurations - Reworked the Run/Debug Configurations dialog for Spring Boot projects. The design is similar to previously updated configurations for Java. The new interface presents the key settings on one screen and allows you to configure more parameters via Modify Options.
    • Improved support for Spring Boot application files - IntelliJ IDEA now provides code completion in additional configuration files (properties or .yaml files) when a spring.config.import key is used to reference another file. It is also better at setting up complex and custom Spring Boot configuration files.
    • References to application.yaml - For Spring Boot projects, the IDE now supports code completion and find usages for references to application.yaml from @Value, @Scheduled, and Environment.getProperty().
    • Better support for @NamedQuery used from Spring Data repositories - 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.
    • Kotlin support for Java EE CDI - Starting from v2021.3, you can use all CDI inspections in Kotlin files. Previously these inspections only worked in Java files. CDI gutter icons have been added in Kotlin files. They allow you to navigate easily to injection points or injection candidates, bean makers, disposer methods, and events.
    • Improved UML class diagrams - Improved the speed of all the processes for UML class diagrams, both in Java and Kotlin. Diagram opening, switching between categories, zoom, and the undo/redo functionality now all take much less time. Other notable changes include a new grid, member highlighting, and a quick documentation preview pop-up. If you need to control the appearance of the diagram, use the context menu and select Appearance.
  • Database tools
    • Data editor aggregates - Added the ability to display an Aggregate view for a range of cells. This will help you manage your data and spare you from having to write additional queries. This makes the data editor more powerful and easier to use, bringing it a step closer to Microsoft Excel and Google Spreadsheets. Select the cell range you want to see the view for, then right-click and select Show Aggregate View.
    • Mapping the DDL data source and the real one - This release is a logical continuation of the previous one, which introduced the ability to generate a DDL data source based on a real one. Now, this workflow is fully supported. You can:
      • Generate a DDL data source from a real one.
      • Use the DDL data source to map the real one.
      • Compare and synchronize them in both directions.
      • Just as a reminder, a DDL data source is a virtual data source whose schema is based on a set of SQL scripts. Storing these files in the Version Control System is a way to keep your database under the VCS.
      • 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.
    • New database diff window - The new Database Diff window is available from the context menu.
      • It has a better UI and clearly shows in the right-hand pane what result you’ll get after you perform the synchronization. The legend in the right-hand pane shows what the colors mean for your potential result:
        • Green and italic: object will be created.
        • Grey: object will be deleted.
        • Blue: object will be changed.
      • The Script preview tab shows the result script, which can be either opened in the new console or run from this dialog. The result of this script is applying changes to make the database on the right (target) a copy of the database on the left (source).
      • Besides the Script preview tab, there are two more tabs on the bottom pane: Object Properties Diff and DDL Diff. They display the difference between the particular versions of the object in the origin and in the target databases.
    • Introspection:
      • Introspection levels (Oracle) - Introduced three levels of introspection for Oracle databases:
        • Level 1: Names of all supported objects and their signatures, excluding names of index columns and private package variables
        • Level 2: Everything except source code
        • Level 3: Everything
      • Introspection is fastest on level 1 and slowest on level 3. Use the context menu to switch the introspection level as appropriate.
      • The introspection level can be set either for a schema or for the whole database. Schemas inherit their introspection level from the database, but it also can be set independently.
      • The introspection level is represented by the pill-looking icons located next to the data source icon. The more the pill is filled, the higher the level. A blue icon means that the introspection level is set directly, while a grey one means that it is inherited.
  • QA tools
    • Editing Selenium page objects - Added support for UI test automation in Selenium – the visual editor can now help you to maintain existing page object classes. Previously, it was only possible to generate new page object classes, but now you are even able to update the existing page object classes directly without a visual editor. IntelliJ IDEA will detect page object classes automatically and indicate them with a corresponding icon on the gutter panel. By clicking on that gutter panel, the user can open a visual editor and grab new elements to be added to the page object class.
    • Test Data - In the newest plugin from the Test Automation Kit, you can now modify the prefix, suffix, and delimiter with a multiline definition in multiple data generator settings.
    • Test Management:
      • Test Run Hierarchy - Added support for multilevel test runs. 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.
      • Shared steps - If you choose to manage test cases in Markdown files using the “Local TMS” feature, you will be able to easily declare test steps and share them among multiple test cases. Shared steps are declared as a regular Test Case with a unique numeric ID. You can refer to that test case in other test cases and IntelliJ IDEA will substitute those referenced test case steps when generating previews, test runs, or code templates for an automatic test.
  • Kubernetes
    • Improved formatting for Helm templates - You can now format your Helm templates and be sure of the correct result. All the related issues have been fixed, and the formatting is now much more reliable. To see the improvement, go to Code | Reformat code or Reformat file or press ⌥⌘L on macOS or Ctrl+Alt+L on Windows and Linux.
    • Highlighting of block elements in Helm templates - Added highlighting of such block elements as if, else, range, with, and define in Helm templates. This makes it a lot easier to work with code that contains Go templates inclusions.
    • Language injection in ConfigMap resources - IntelliJ IDEA now supports automatic code injections of various languages in ConfigMap resources for keys with extensions like .yaml, .json, .properties, and so on. The injected pieces of code are highlighted in green, and it is possible to use the code insight functionality inside them, including code completion, error highlighting, and others.
    • Ability to repeat the latest command - It is now possible to rerun your latest helm command from the Services tool window. All you have to do is click the new icon in the top right-hand corner.
  • Docker
    • Connection to Docker from Minikube - It is now easy to connect to a Docker daemon from Minikube. In Preferences/ Settings | Build, Execution, Deployment, select the Minikube radio button. In the field next to it, the IDE will automatically display the detected Minikube's docker-daemon environments that you can use for connecting.
    • Easier connection process - Connecting to Docker has become faster 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.
    • New Clean up action - The new Clean up action works just like the prune terminal command. When you right-click on the Networks, Volumes, Containers, or Images node, you can select Clean up, and the IDE will delete the unused objects. You can also apply this action to the Docker root node to prune all the unnecessary objects in one click.
    • Support for Compose V2 - IntelliJ IDEA now supports Compose V2, which allows you to run Docker Compose commands as docker compose, instead of docker-compose (with a dash). To activate this option, go to Preferences/Settings | Build, Execution, Deployment | Docker | Tools and tick the Use Compose V2 checkbox.
    • Image layers - Image layers allow you to track all the commands that are applied to images. To access them, select an image and go to the Layers tab. From there, when you choose a command, you can click on the Analyze image for more information link on the right-hand side of the screen for more detailed info about the changes applied to each layer.
    • Save container as image - If you have a preconfigured container that you want to use later, you can save it as an image locally and push it to continue using it remotely when you need it. Go to the Services tool window, right-click on the container, and select Image | Save as a new Image.
    • Registry updates - Added several changes to the Docker registry:
      • The IDE now displays all available registries in separate nodes in the Services tool window.
      • Previously there was only support for the Docker Hub registry. In v2021.3, support for GitLab (registry.gitlab.com) and JetBrains Space (<username>.registry.jetbrains.space) has been added.
      • You can expand the registry nodes in the Services tool window, select the necessary image, and pull it to the desired location. If you have several Docker connections, the IDE will ask you where to pull the image.
      • It is now possible to push images to any added registry, and in the Push dialog the IDE automatically detects the available namespaces in the given registry and lets you select one from the drop-down list.
      • You can now use image completion for images from the JetBrains Space, GitLab, and Docker Hub registries.
    • Podman support - IntelliJ IDEA now supports Podman as an alternative way to manage pods, containers, and images. Before using Podman in the IDE, configure a connection yourself. Once Podman has been installed and configured on your OS, you can connect to it via Preferences/Settings | Build, Execution, Deployment | Docker by selecting the TCP socket radio button and filling in the required fields.
  • Space integration
    • Create merge requests and create code reviews from the IDE - You can now create merge requests and code reviews for your projects in Space. You have 2 different options:
      • Click the + icon on the top toolbar of the Code Reviews tool window and select the desired action.
      • In the Log tab of the Git tool window, right-click the commit in the list and choose Space | Create merge request or Create code review.
    • Mark files as viewed - All the files that you haven’t yet revised when performing a code review will remain marked with blue dots until you open them. This way, you won’t miss any critical changes. If you want to return to the changes later, you can select Mark as Not Viewed from the context menu. This feature also works for GitHub pull requests.
  • Other
    • IntelliJ IDEA now supports Android Studio Arctic Fox, 2020.3.1.
    • Added 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.
Troubleshoot IDE issues

IntelliJ IDEA

Vollständige Umgebung für die Java-Entwicklung.

Sie haben eine Frage?

Live-Chat mit unseren JetBrains-Lizenzierungs-Spezialisten.