Deep insight into your code

IntelliJ IDEA analyzes your code, looking for connections between symbols across all project files and languages. Using this information it provides indepth coding assistance, quick navigation, clever error analysis, and, of course, refactorings. Smart completion Ctrl+Shift+Space gives you a list of the most relevant symbols applicable in the current context. This and other completions are constantly learning from you, moving the members of the most frequently used classes and packages to the top of the suggestions list, so you can select them faster. Chain completion Digs a tad deeper than Smart Completion and lists applicable symbols accessible via methods or getters in the current context. Say you're looking for a value of Project and only have the Module module declaration. Press Ctrl+Shift+Space twice to get module.getProject() without any additional effort. Static members completion Lets you easily use static methods or constants. Offers a list of symbols matching your input and automatically adds required import statements. Data flow analysis When offering completion variants, IntelliJ IDEA analyses data flow to guess the possible runtime symbol type and refines choices based on that intel, automatically adding class casts. Language injection Brings coding assistance for a selected language to expressions and string literals in another one, complete with all advantages you would normally have. For example, you can inject fragments of SQL, XPath, HTML, CSS, or JavaScript code into Java String literals. Cross-language refactorings Knowing everything about usages of a symbol, IntelliJ IDEA offers extremely effective, thorough refactorings. For example, when you Rename a class within a JPA statement, it will update everything, from JPA entity class, to every JPA expression where it is used. Detecting duplicates Finds duplicate code fragments on the fly. Even if you're only about to extract a variable, constant, or a method, IntelliJ IDEA will let you know that there is a similar code fragment that can be replaced along with the one you're woking on. Inspections and quick-fixes Whenever IntelliJ IDEA detects that you're about to make a mistake, a little lightbulb pops up in the editor. Clicking it or pressing Alt+Enter opens a list of actions you can take to make things right. Developer ergonomics

Every aspect of IntelliJ IDEA is designed with ergonomics in mind. IntelliJ IDEA is built on a principle that every minute a developer spends in the flow is a good minute, and things that break developers out of that flow are bad and should be avoided. Editor-centric environment Most of your time the editor (and the code) is the only thing visible on your screen, and you don't need to leave it to do something that isn't coding-related. Quick popups are helpful for checking additional information without leaving the context that you’re in. When you press Ctrl+Shift+I it shows you the definition for the symbol at caret. To generate code, you don't have to walk through complex wizards or fill huge forms. Shortcuts for everything In IntelliJ IDEA you have dedicated keyboard shortcuts for nearly everything, including rapid selection and switching between tool windows and the editor. Accessing a tool window via its shortcut moves the input focus to it, so you can use all keyboard commands in its context. When you need to go back to the editor, just hit Esc. When you're in the Project tool window, you can not only navigate through the existing items, but also create new ones by just pressing Alt+Ins. Ergonomic user interface All lists, trees and popups in IntelliJ IDEA provide you with quick search that instantly takes you to a set of items that contain text you’re typing in them. The first call of any IDE action is supposed to provide most expected results. Need more results? Press the shortcut again and the IDE will go deeper to find what you need. Inline debugger When you debug your code IntelliJ IDEA shows you variable values right in the source code, next to their usages. You don’t even have to hover the mouse over the variable, or switch to the Variables pane of the Debug tool window. Any time a variable changes its value, the IDE highlights it with a different color so that you can better understand how the state is changed over the code. Built-in developer tools

To streamline your workflow, IntelliJ IDEA offers an unbeatable toolset right from the first start: decompiler, bytecode viewer, FTP and many more. Version control IntelliJ IDEA provides a unified interface for major version control systems including Git, SVN, Mercurial, CVS, Perforce, and TFS. The IDE lets you browse the history of changes, manage branches, merge conflicts and much more Build tools IntelliJ IDEA supports Maven, Gradle, Ant, Gant, SBT, NPM, Webpack, Grunt, Gulp and other build tools. Seamlessly integrated, these tools help automate compilation, packaging, running tests, deployment and other activities Test runner and coverage IntelliJ IDEA lets you perform unit testing with ease. The IDE includes test runners and coverage tools for major test frameworks, including JUnit, TestNG, Spock; Cucumber, ScalaTest, spec2, and Karma. Decompiler IntelliJ IDEA comes with a built-in decompiler for Java classes. When you want to take a look inside a library that you don't have the source code for, now you can – without any third-party plugins. Terminal The IDE comes with a built-in terminal. Depending on your platform, you can work with command line prompt, Far, powershell, or bash. Invoke the terminal with Alt+F12 and execute any command–without leaving the IDE. Database tools Take advantage of intelligent coding assistance when editing SQL; connect to live databases; run queries; browse and export data; and even manage your schemes in a visual interface–right from the IDE. Application servers IntelliJ IDEA supports major application servers: Tomcat, JBoss, WebSphere, WebLogic, Glassfish, and many others. You can deploy your artifacts onto application servers and debug the deployed applications right from within the IDE. Docker Via a separate plugin, IntelliJ IDEA provides a dedicated tool window that lets you connect to locally running Docker machines to manage images, containers and Docker Compose services. Polyglot experience

In addition to Java, IntelliJ IDEA offers first-class support for top JVM and non-JVM frameworks and languages out of the box. First-class support for top frameworks IntelliJ IDEA provides support for the most popular server-side and front-end frameworks. Take advantage of extended coding assistance for Spring, Java EE, Grails, Play, Android, GWT, Vaadin, Thymeleaf, React, AngularJS and other frameworks. Many languages–one IDE While IntelliJ IDEA is an IDE for Java, it also understands many other languages, including Groovy, Kotlin, Scala, JavaScript, TypeScript and SQL. IntelliJ IDEA is a turnkey solution, but if you ever need anything extra, its rich plugin ecosystem is here to help you.

Java 13 IntelliJ IDEA is getting ready to welcome new Java 13 Preview features. The IDE provides support for updated Switch Expressions and their new syntax: now if you need to return a value from a multi-line block in Java 13, you can use the yield keyword instead of break. We’ve also added support for text blocks, which allows you to embed longer multi-line blocks of text into your source code, for example, HTML or SQL. With this feature, you paste across the two formats, either escaping values when pasting into a String or leaving out the escapes when pasting into a text block. Refactoring methods with multiple exit points We’ve added a new intention that you can run to transform a method with multiple returns into a single exit point and prepare it for the Inline Method refactoring. A method may include multiple exit points by defining multiple return statements. When you inline such a method in IntelliJ IDEA, it can be modified to define just one exit point in the form of a single return statement to exit the method. Such methods are less confusing as you have one path through them and you don’t need to search for the exit. ‘Constant conditions & exceptions’ pinpoints the source of the problem We’ve topped off the good old ‘Constant conditions & exceptions’ inspection with a new action called ‘Find Cause’. In addition to notifying you about possible or actual issues, the inspection navigates you to the questionable piece of code. No more reading through the file and searching for the necessary line. Modified inspection weeds out duplicates from your code (ULTIMATE) We’ve merged the ‘Duplicated code fragment’ inspection for Java with the ‘Locate duplicates’ tool for other languages, to give you a powerful new inspection called ‘Duplicated code fragment’ which combines the best of both worlds. It’s configurable, works on the fly, and supports lots of languages other than Java. Updated completion popup suggests correcting mistyped patterns In IntelliJ IDEA 2019.2, we’ve changed the look of the code completion popup and made it even more helpful. From now on, completion recognizes mistyped patterns and suggests possible fixes, so if you type “retru” by accident, the IDE will suggest replacing it with “return”. Structural Search shows occurrences instantly Structural Search is a powerful feature that allows you to search for a specific code pattern in your project. IntelliJ IDEA highlights strings that match your search in the editor as you type. What’s more, the IDE displays the filter values right in the editing area of the Structural Search dialog. There is no more need to continuously re-run the search while you are experimenting with the pattern. Profiling Tools

IntelliJ IDEA now offers profiling tools (ULTIMATE) Now you can analyze the performance of your application right inside your IDE as IntelliJ IDEA is integrated with Java Flight Recorder on Windows, macOS, and Linux. macOS and Linux users can also enjoy the Async Profiler. This tool can easily become your best friend as it tells you everything about how memory and CPU are allocated in your application. Services

Services tool window: a single control panel for all connections, configurations, and more Now you have everything you need to control all under one view. A brand new Services tool window condenses and encapsulates the most useful tools: RunDashboard, Database Console, Docker, and Application Servers views. It also provides a single display and control point for connections, run and debug configurations, application servers, database consoles, and more. For databases, the tool window features the query live timer which shows you the duration of each connection running a query. A running Docker container lets you view its file system In IntelliJ IDEA 2019.2, you can view the file system of a running Docker container in the Files tab of the Docker node in the Services tool window. Performance

This release improves the performance and UI responsiveness for the file system refresh, and reduces most delays caused by processing filesystem changes. We’ve gone to great lengths to optimize the startup performance, so you should feel a boost as soon as your start the IDE. Editor

Each directory can have its own code style You can now have a separate code style configuration for each folder. Fancy trying it? Place an EditorConfig file in the root directory of a module or a package, and you are good to go. The IDE can now manage all code style settings via the EditorConfig file. All adjustments are now visible in the preview, so your days of blind fiddling with the settings are over. Syntax highlighting is available for over 20 languages IntelliJ IDEA is now integrated with the TextMate editor to provide out-of-the-box syntax highlighting for over 20 different programming languages. If you need to add highlighting for any additional languages, all you need is to do is to download the TextMate bundle for the language and import it into the IDE. The ‘Move Caret to Next Word’ action provides options Now you can choose where to place the caret: at the end of the current word or at the beginning of the next word. Pick the behavior that works best for you in the Caret Movement option in Settings/Preferences | Editor | General. Tab now takes you outside the closing bracket or quote Another feature to help you type faster is now enabled out of the box: the Tab key navigates you outside of the closing brackets or quotes. This feature works only when you’re typing. To disable this option, go to Settings/Preferences | Editor | General | Smart Keys and deselect the ‘Jump outside closing bracket/quote with Tab when typing’ checkbox. Selected code gets wrapped in quotes or braces automatically Although it’s not technically brand new, this super handy feature is now enabled by default: when you type a brace or a quote, IntelliJ IDEA automatically wraps the selected code in braces or quotes. If you don’t like this feature as much as we do, go to Settings/Preferences | Editor | General | Smart Keys and deselect the ‘Surround selection on typing quote or brace’ checkbox. IntelliJ IDEA works with large files smoothly You can now easily open files larger than 25MB in IntelliJ IDEA and search through them without tedious waiting. This is a very nice little improvement for those of you who work with the log files. Appearance

Inspection popup shows the most relevant fix This release delivers fixes suggested by code inspections even faster. Now the inspection popup not only describes the problem, but also shows you the most relevant solution straight away. Press Alt+Shift+Enter if the fix works for you, or use the Alt+Enter shortcut to pick another option from the list. New Class dialog gets a new look The New Class dialog has a new look. What’s more, now it lets you preview the types of classes you can create. Windows User interface has a fresh classy appearance On Windows 10, the IDE now has a new modern borderless look. Project View now shows file size and modification time A new option helps you keep an eye on what’s going on in your project and shows the size and modification timestamps for all items in the Project View tree. To enable the feature, select View | Appearance | Descriptions in Tree Views. Editor and debugger tabs get a unified look The design of the editor and debugger tabs has changed to look the same in the Light and Darcula themes. In the Light theme, we’ve aligned the tab’s height with the height of the tool window header. We’ve also removed the white line under the tabs to minimize visual clutter. Find Usages toolbar becomes more elegant Continuing the trend of removing unpopular icons from toolbars and making them less visually loaded, we’ve trimmed down the toolbar of the Find Usages tool window. Some icons are now grouped and some are gone completely. Gradle

Gradle features a new Dependencies diagram (ULTIMATE) In this release, we’ve added the long-awaited Gradle Dependencies diagram. Just click the Show Dependencies icon on the Gradle tool window toolbar or press Alt+Shift+Ctrl+U/Alt+Shift+Cmd+U. Select the nodes from this diagram to look at their neighbors, and click the nodes to see how they are connected to the root. More coding assistance features added for build.gradle files Starting with version 2019.2, you can edit build.gradle files more easily. IntelliJ IDEA now supports the task declaration syntax and various dependency notations, and offers code completion inside dependency blocks and dependency configuration closures. Gradle task output is improved The status tree and output console of Gradle operations are now shown side by side to help you monitor the sync/build process. This offers you more detailed and familiar Gradle output information. Working with Gradle settings gets easier We’ve simplified the Gradle settings dialog by deprecating several options. What’s more, IntelliJ IDEA automatically configures the settings for you when you open, import, or create Gradle projects. Maven

Maven sync output is shown in the Build tool window IntelliJ IDEA now reports the Maven import process in the Build tool window, together with the Maven build output. This makes the progress and error reporting more visible, simplifies navigation, and makes the Gradle/Maven experience more consistent. Maven dependency completion works out of the box Code completion for dependencies in the pom.xml now works out of the box. Previously, it only worked if you triggered the indexing of your Maven repository. Version Control

The native ignore file handling is now fully supported In this release, we added the native ignore file handling for Git. From now on, the native ignore file handling is available for all supported version control systems out of the box. You will no longer need to manually add files to the .gitignore list in the settings. Everything is much simpler now: add a file to the list of ignored files from either the Project Tree or the Local Changes tab of the VCS tool window. The .ignore plugin that used to offer Git ignore and HG ignore support now only provides advanced functionality of VCS ignores, as the main functionality is part of the platform. Commit files from the Local Changes tab IntelliJ IDEA 2019.2 brings a big change for projects that use Git or Mercurial. There’s no need to open a separate dialog to commit files; now you can commit files from the Local Changes tab of the Version Control tool window. There, you can review the modified files and make changes if necessary because the commit dialog doesn’t block the rest of the IDE. To give it a go, select the ‘Commit from the Local Changes without showing a dialog’ checkbox in Settings/Preferences | Version Control | Commit Dialog. Smart VCS integration reminds you to commit files IntelliJ IDEA 2019.2 reminds you to modify the files you have usually committed before together with the files you modified recently. The IDE suggests adding files copied externally to VCS IntelliJ IDEA prompts you to add any files copied into the project from outside the IDE, or files created in the console or during code execution to version control. You can also configure the IDE to add such files automatically. VCS Log tab allows you to select the information to show Now you can choose which columns you want to see in the VCS Log tab. Click the eye icon, select ‘Show Columns’, and then select the columns you want to display: author, date, or commit hash. Git Merge and Cherry-Pick can be aborted from the UI Now you don’t need to switch to the terminal to abort Git Merge or Cherry-Pick anymore. The Abort Merge/Abort Cherry-pick option shows up in the Branches popup while the process is running. Show History for a folder displays results on the Git Log tab Track changes in your project with ease. Now, when you use the Git | Show History action on the selected directory in the Project View, the IDE displays the results in the Log tab filtered by the respective path. You can also see the changes that were made in multiple folders all at once. Right-click the folders where you want to check the updates and select Git | Show History. Update Info after Update Project action is shown as Log tab Previously, when you used the Update Project and Pull actions, the IDE would show a tree of updated files in the Update Info tab of the Version Control tool window. In v2019.2, the Update Info is displayed as a list of commits received during the update. The Update Info tab now looks like the Log tab. Comparing branches becomes more convenient The ‘Compare with Current’ action in the Branches popup is divided into 2 separate actions: ‘Compare with Current’ and ‘Show Diff with Working Tree’. The updated ‘Compare with Current’ action now shows the difference in commits, while the new ‘Show Diff with Working Tree’ action shows the file diff. Diff now shows the method with modified code While in the “Collapse Unchanged Fragments” mode, the Diff now shows the method in which the current chunk of code is modified. It makes it easier for you to not only see the change, but to understand the context as well. Kotlin

The bundled Kotlin plugin in IntelliJ IDEA is now updated to v1.3.41. JPA for Kotlin gets more coding assistance features (ULTIMATE) IntelliJ IDEA 2019.2 comes with a wider range of JPA coding assistance features for Kotlin. Now you can generate Kotlin entity classes on selected tables with the Generate Kotlin Entities script. The script is easily customizable; go to the Scripts Directory and experiment with the script by modifying it to solve a specific task. What’s more, the IDE can now navigate you to the corresponding column or table with the ‘Go to Declaration’ action (Cmd+B/Ctrl+B). ‘Async stack trace’ shows the variable state at the last point of suspension When you stop at a breakpoint inside a suspend function or a lambda, ‘Async stack trace’ now shows you the state of the variables at the last point of suspension. You can browse the whole stack trace of suspend functions starting from the last suspension point in the current coroutine and check the stored values of the variables. This can help you understand how you got to the current point of execution. Interactive mode for scratch files shows changes on the fly As you know, in Kotlin you can perform small experiments with your codebase using scratch files. Now you can use the interactive mode which shows you the results on the fly after a certain timeout, without the need to explicitly rerun the script. TODO list displays multiline comments for Kotlin How often do you check the TODO list in your project? IntelliJ IDEA now correctly highlights multiline TODO comments in Kotlin and displays them as a list in the TODO tool window. The IDE warns you on incorrect external annotations If you use external nullability annotations for Java, the IDE can now warn you about incorrect usages of annotated Java methods from Kotlin. Note that this is purely IDE functionality; the corresponding code is compiled without warnings by the Kotlin compiler, while the IDE shows an additional warning. Groovy

We’ve extended the Groovy 3.0 syntax and our support for nested code blocks. Moreover, the IDE now makes the braces and arrows in a closure expression bold by default so that you can easily understand the structure of the code and distinguish code blocks from closures. You can also enjoy quick-fixes that add explicit types for all the parameters in a method declaration for Groovy methods where the types of the parameters aren’t explicitly defined. Scala

New way to highlight type mismatches Instead of underlining type mismatch errors with a red squiggle, which might span across multiple lines, IntelliJ IDEA now shows a type ascription hint and highlights the part that doesn’t match the expected type. Type mismatch tooltips show diff Type mismatch tooltips are now fine-grained, vertically-aligned, and offer pairwise comparison. The algorithm takes syntactic sugar, subtyping, variance, and other tricky stuff into account. Type hints are interactive Type annotation hints now support dynamic folding, tooltips, navigation, and brace matching. The type hints are now shown only when truly needed. Expressions are wrapped / unwrapped as you type Previously, you had to use intentions to wrap (or unwrap) expressions inside curly braces. Now IntelliJ IDEA can do that automatically, as you type. Redundant code is now unobtrusive IntelliJ IDEA has always used grey to mark unused imports or unreachable code as “redundant” (as defined by the color scheme). Some other redundant code, however, was highlighted as “generic warning or error”, which polluted code and concealed actual errors. Now we use grey to color all redundant code uniformly, so the highlighting is less obtrusive. Improved code completion You can now complete the whole case clause (whereas before, it was only possible to complete patterns in case clauses). Completion works not only for match statements, but for higher-order functions as well. Enhanced language injections (ULTIMATE) Now you can inject languages into multiline string literals with margins. Build Server Protocol is fully supported IntelliJ IDEA now supports the Build Server Protocol (BSP), which standardizes how build tools (servers) and IDEs (clients) communicate with each other. For a while, BSP support was an experimental feature, but now it is a first-class citizen in the IDE. JavaScript & TypeScript

New intention replaces an extra variable with another destructuring (ULTIMATE) With the new ‘Propagate to destructuring’ intention (Alt+Enter), you can replace an extra variable with another destructuring whenever possible. To remove a destructuring completely, use the intention action called ‘Replace destructuring with property or index access’. The IDE now warns you if a boolean expression in a condition has some unnecessary parts and suggests simplifying it. Rename refactoring for JavaScript is now enhanced (ULTIMATE) When you rename a symbol in a JavaScript or TypeScript file, the IDE now groups together dynamic usages and, by default, excludes them from the refactoring. This makes the refactoring more accurate and gives you more control over what exactly should be renamed in the Refactoring Preview tool window. Improved support for Vue.js allows for better completion (ULTIMATE) Using Vuetify or BootstrapVue in your Vue.js application? We’ve adopted a new approach to working with these libraries in the IDE. From now on, code completion for components and their props from these and some other Vue component libraries is more precise. Node.JS is now bundled with IntelliJ IDEA Ultimate (ULTIMATE) The Node.JS plugin now comes pre-installed with IntelliJ IDEA Ultimate. Database Tools

Full-text Search offers comprehensive results (ULTIMATE) Now you can search for the data you need even if you don’t know its exact location. Right-click the data source or a group of data sources that you want to search through and select Full-text Search, or press Ctrl+Alt+Shift+F / Cmd+Alt+Shift+F. The results are filtered to show you only those strings in which the data is found. If you cannot locate the data because there are too many columns, use the text search in the data editor (Ctrl/Cmd+F). Filtering by data source available in search and navigation (ULTIMATE) Locating an object in the GoTo popup is not always easy, especially when there are too many similar items. In IntelliJ IDEA 2019.2, you can choose where to search: in a particular data source or in a group of sources. The same works for Find In Path. This is extremely useful if you are looking for source code inside of DDLs of other objects. JVM Debugger

Step Into action offers you a choice of methods to step into When you’re doing ‘step into’ on a line with several methods calls, you can choose the method, lambda, or method reference that you want to step into. Shell Script

IntelliJ IDEA introduces shell script support This release offers rich editing support for shell scripts, including word and path completion, Quick documentation, and even textual rename. You can also create run configurations for executing shell scripts – and that's only half the story. We’ve integrated several external tools into IntelliJ IDEA for even more advanced shell script support. From now on, you can use Shellcheck to detect and fix errors in your script, Shfmt to properly format your shell script, and Explainshell to get a full description of the necessary command by pressing Alt+Enter. HTTP Client

HTTP client supports cURL requests (ULTIMATE) Now you can paste a cURL request string into the HTTP client and have the IDE automatically convert it to a full request. HTTP client keeps cookies (ULTIMATE) Suppose you’ve made one request to authenticate on the service, and in subsequent requests you would like to call some endpoints that require additional permissions. Previously, you would lose the cookies from the first response. But not anymore: the IDE now keeps all the cookies for you and transfers them in the next requests. Terminal

The Terminal soft-wraps lines better Previously, the Terminal could occasionally break links when wrapping lines, and some lines were wrapped improperly. Now, when you run a command that outputs a long line, the Terminal soft-wraps it gently, keeping all the links in the working state. If you click a wrapped link, it is immediately sent to your browser. Exit codes for file merge from the command line IntelliJ IDEA now returns proper exit codes when used as a command line tool for merging files. Now you can use IntelliJ IDEA as a merge tool in any custom workflow. We also support the --wait command line option for editing files from the terminal in a blocking manner. Plugins

Plugins page becomes more ergonomic The IDE now displays plugin details on the Plugins page in the Settings/Preferences dialog right away, so you don’t have to click each plugin one by one. We’ve got rid of the Updates tab, and the ‘Update’ button is placed near the plugin name on the Installed tab. We’ve added new options under the gear icon, allowing you to disable or enable the downloaded plugins all at once. Save yourself a bunch of clicks and spend them on more important things. Kubernetes

Kubernetes plugin gets Kustomize support (ULTIMATE) The new version of IntelliJ IDEA 2019.2 with the Kubernetes plugin provides editing support for Kustomize with completion for keys and paths, as well as many inspections for Kustomize resource files. The Rename refactoring now works for renaming the files and directories of the Kustomize resource files. You can jump from a path declared in the Kustomize resource files to the associated packages or files in the Project tool window, with the Ctrl+B/Cmd+B shortcut. External resources can be added using URLs (ULTIMATE) You can now load a custom resource definition (CRD) specification from external sources using URLs. To add the specifications, go to Settings/Preferences | Languages & Frameworks | Kubernetes and add URLs to the CRD specification. (Previously, it was possible to add a CRD from local files.)

1. Установите программу; 2. Разместите файл jetbrains-agent.jar в любой удобной для вас папке; 3. Активируйте триальный период: - Запустите приложение - В окне активации выберите пункт "Evaluate for free" - Нажмите кнопку "Evaluate" для получения лицензии на 30 дней; 4. Подключите файл jetbrains-agent.jar в параметрах JVM: * В окне приветствия -> "Configure" -> "Edit Custom VM Options..." * В открытом проекте -> "Help" -> "Edit Custom VM Options...", согласитесь на создание файла В конец открывшегося конфигурационного файла добавьте строчку -javaagent:Абсолютный\Путь\До\Файла\jetbrains-agent.jar; 5. Перезапустите IDE, чтобы пересчитались параметры JVM; 6. Активируйте постоянную лицензию: * В окне приветствия -> "Configure" -> "Manage License..." * В открытом проекте -> "Help" -> "Register..." а) Способ с сервером лицензирования (при работающем интернете): - Выберите способ "License server" - Нажмите "Discover server" для автоподстановки адреса, либо введите в поле адреса http://jetbrains-license-server б) Офлайн способ с кодом активации (если доступа в интернет нет): - Выберите способ "Activation Code" - Скопируйте код из файла ACTIVATION_CODE.txt и вставьте в соответствующее поле Нажмите кнопку "Activate" для применения выбранного типа лицензирования.

PS в файле hosts не должно быть записей для доменов JetBrains, иначе может не сработать лечение