What′s New in GoLand

GoLand 2019.3 consumes less CPU and performs faster, boosts its Go Modules support, adds a set of new quick-fixes, and enhances the refactorings. It’s possible to call a method of an embedded field via Evaluate Expression and debug your applications remotely using Mozilla rr.

You can also enable a Global File Watcher for every new project, work with MongoDB, and more!

2019.3 Nov 29


A chart with the startup times measurement of GoLand 2019.3 on different operating systems

Since releasing GoLand 2019.2 this summer, we’ve been working hard to make GoLand perform faster and consume less CPU. One of the major performance improvements is reducing the startup times, when the IDE prepares everything under the hood, displays the welcome screen, and indexes a project.

Please note that results may vary depending on the size of your project and your device’s age, RAM, and disk space. We will keep working on this, so you can expect even faster startup times in future releases.

Go Modules improvements

Navigation from go.mod file to the Project View

GoLand 2019.3 provides syntax highlighting and navigation for go.mod files. Press ⌘+B on macOS or Ctrl+B on Windows/Linux on a specific dependency import path, and GoLand will navigate you to its sources in the Project View.

Also, in the Project View, the Go Modules will be displayed with their full import path instead of just the last segment of it. The version of each Go Module will also be shown in a more muted font color than the import path, to help you easily distinguish between them.

Debugger updates

Evaluate Expression dialog with the result of call

Call Method of an Embedded Field

Evaluate Expression in the debugger now lets you call a method of an embedded field directly.

Debugging with Mozilla rr

Remote debugging with Mozilla rr

Many production services written in Go run on Linux and Mozilla rr can help investigate bugs that are difficult to reproduce. Mozilla rr debugging is supported starting from GoLand 2018.3, but it used to work only on developer machines running Linux. Now, it is possible to start a debug server on a Linux machine and to debug the trace remotely from macOS and Windows. Follow these steps:

  • Collect an rr trace on the remote machine.
  • Start the debugger on the remote machine like this: dlv --headless --api-version 2 -l localhost:2345 replay /path/to/trace/dir /path/to/binary.
  • Connect to the remote machine via the Go Remote configuration.

Please note Mozilla rr is available only on Linux machines.

New quick-fixes

Delete unused parameter name from the expression via Alt+Enter

Handling unused parameters

For an unused parameter, GoLand now highlights its name and type if both can be removed, or only the name if the type is used for implementing a method specification.

In the latter case, the IDE provides two quick-fixes for you to choose from: Delete parameter names or Rename to_. The same behavior is provided for functions that are used as a function type

Also, now it’s possible to remove all the unused parameters in one go. Press Alt+Enter and use the Delete all unused parameters quick-fix.

Create a missing function

Create missing method or function

GoLand provides a quick-fix to create a missing function or method when it's used in a function type. Just press Alt+Enter and choose Create method/function.

GoLand suggest to import package

Enhanced handling of package aliases

GoLand now suggests importing packages based on their used aliases via Alt+Enter in any file in your project.


Types of parameters are shown in the Parameters and Result Parameters tabs

Change Signature

Change Signature now always shows the type of parameters in the Parameters and Result parameters tabs. Tick the new Reuse types checkbox to collapse consequence types in the Signature Preview and the result.

In addition, you will find two new intention actions, Reuse signature types which merges parameter definitions in a single declaration, and Expand signature types which adds types to each parameter via Alt+Enter.

Extract Variable suggests err for expression of type error

Extract Variable & Rename

Extract Variable and Rename are now better at suggesting names. For example, err is suggested for expressions of type error, ctx is suggested for context.Context, and so on.

Improved behavior of Code Inspections

Comparison of code inspections behavior between 2019.2 and 2019.3 versions

GoLand’s code inspections are more focused now. We've reduced the highlighting range of the detected issues in the code editor, to help show the most relevant quick-fixes and intention actions for a particular piece of code when you invoke the context menu via Alt+Enter.

Code Editing

An example of the error message for rune literal

Improved rune literal lexer

We’ve improved the rune literal lexer in several ways:

  • GoLand provides a clearer and more concise error message explaining why the expression is incorrect.
  • GoLand doesn’t highlight a valid rune literal as an error after editing.
  • Parsing of invalid rune literals is more stable.
GoLand highlights reassignment in the left-hand side of declaration

Highlighting for reassignments

Go allows using existing variables on the left-hand side of short var declarations. Thus, two constructs that look the same can have different meanings. To make this easier to spot, we’ve added syntax highlighting for such reassignments.

An example of code folding for composite literals

Code folding for composite literals

GoLand 2019.3 provides code folding for composite literals. Use the code folding toggles to fold or expand the code fragment, or press Ctrl+NumPad Minus/Ctrl+NumPad Plus on Windows or ⌘+NumPad Minus/⌘+NumPad Plus on macOS. To configure the default code folding behavior, go to Settings/Preferences | Editor | General | Code Folding.

Live templates enhanced

forr live template suggests line as a value

The live templates for and forr now suggest relevant variable names. For example, names like i and index are suggested for an index; s, string, and line are suggested for a value.

The live template meth now provides code suggestions for receiver names.


Search only in the selected area

Search only in a selected area

Search only in a selected area when using Find (⌘+F on macOS and Ctrl+F on Windows/Linux). Simply select the piece of code you need in the editor and invoke Find – the IDE will then perform the search only in the selected area. To easily switch to searching within the whole file, press ⌘+F/ Ctrl+F a second time, or toggle the In Selection option in the bar.

Searching with ‘Find in Path’ with a file mask option in action

Using ‘Find in Path’ with a file mask option

Now, when you search in the Find in Path dialog using a file mask, GoLand shows the file extensions in the search results accordingly. This makes it easier for you to distinguish between files with the same name but with different file extensions.

Enable Global File Watcher for all new projects

Enabling golangci-lint for all new projects

In GoLand 2018.2, we added an option to share a file watcher configuration among different projects using the options Project and Global – it’s called a Global File Watcher.

However, you would have still needed to enable this watcher in each new project. Now, it’s possible to enable this watcher by default in all new projects you create or open.

In the menu File, select Other Settings | Settings for new projects, then go to Tools | File Watchers, add a new global watcher, and then select the checkbox next to it to enable it in all new projects.


An exercise for the new feature of Extract Variable refactoring

Often there’s not enough time to read the What’s New pages, release notes, and blog posts about the product you use, while you need to finish your project and meet the deadline. That’s why we’ve added Tutorials for you to learn about GoLand features when you are ready.

You can find Tutorials on the welcome screen, above your project list. When you upgrade the IDE to a new version, there will be a lesson covering the features from the new release. Alternatively, you can access Tutorials via a corresponding tool window from any project.

More changes

Switching between the callers and callees in the Hierarchy tool window

Hierarchy tool window

There is a new option to analyze the callees’ method hierarchy in the Hierarchy tool window. We’ve added two dedicated buttons that let you switch between the callers and callees of the selected method. Also, now you can sort the elements within a tree alphabetically, by clicking a special button in the menu. To see the Hierarchy tool window in the Tool Windows list, you need to build a hierarchy first and then go to Navigate | Call Hierarchy or Navigate | Type Hierarchy.

Switching theme plugin without restarting the IDE

Switch theme and keymap plugins on the fly

In GoLand 2019.3, you can install and uninstall any theme plugins and keymap plugins without restarting the IDE.

Select ‘Add Keyboard Shortcut’ in the settings for ‘Focus Editor’ action

A custom shortcut for returning the focus to the editor

Set your custom shortcut for the action that takes the focus back to the editor, instead of using ESC. Find the Focus Editor action in references/Settings | Keymap, right-click it, and select Add Keyboard Shortcut from the drop-down.

More visible scrollbars in the editor

More visible scrollbars

We've added an option to make the scrollbars more visible. To do this, select the Use contrast scrollbars checkbox in Preferences/Settings | Appearance & Behavior | Appearance.

Version control improvements

New Clone dialog with the list of repositories

Reworked Clone dialog

The Clone dialog is located under VCS | Get from Version control. Now you can log in from this dialog, or, if you’re already logged in, the IDE will instantly preview the lists of all repositories grouped by accounts or organizations.

‘Show Details’ opens a window with conflict changes

More insight into merge conflicts

Now it is easier to investigate a conflict during a merge, rebase, or cherry-pick operation. Simply click the Show Details link to get the list of commits that led to the resulting code state, and get more information about the source of the changes displayed in the Merge dialog.

Databases updates

View collections and fields in the database explorer

MongoDB support

GoLand 2019.3 provides basic support for MongoDB. Now you can:

  • View collections and fields in the database explorer.
  • Open any collection or observe the query result. It’s also possible to sort by columns or filter the values.
  • Run queries and get the results. Select a statement and run it by pressing Ctrl/⌘+Enter or by using the Play button on the toolbar.
An example of the connection error

Search for connection error

It’s now easier to explore connection errors. When a connection fails, you can just click the dedicated button in the IDE to move to the search results for your error using the Google search engine.

Web development

Code completion for the class name from CSS library

Completion for CSS libraries on CDN

If you’re using Bootstrap or another CSS library and have it linked from a CDN in your HTML file, you can now get completion for the class names from that library, without adding its sources to the project.

Code suggestions for new variable

Name suggestions for new symbols

When adding new variable and parameter names in JavaScript or TypeScript, you’ll now get name suggestions based on the names of classes, interfaces, and type aliases defined in the project, standard libraries, and dependencies you’re using.

For new variables, functions, classes, and interfaces, you’ll also get suggestions for names that were already used in the same scope but haven’t been defined yet.

2019.2 Jul 25

Function calls support

Call function in the Evaluate Expression dialog

Examine in detail what is going on inside your expression at any specific point in your program’s execution.

Note, that this feature relies on the experimental function call support feature from Delve and the Go Runtime.

If you encounter any bugs or issues with function calls support, please report them to our issue tracker.

Improved Default & Darcula color schemes

Updated Darcula color scheme

GoLand 2019.2 adds variety to the semantic code highlighting in the Default and Darcula color schemes.

This will help you better understand your code and follow its logic faster. Easily distinguish package names from variables, built-in code constructions from your own ones, and type conversions from function calls. Methods’ receivers and functions/function calls now have their own colors, too.

As usual, change everything to your taste in Settings/Preferences | Editor | Color Scheme.

Debugger updates

The debugger shows the results of String() method implementations in the Variables pane

More info about variables with String() method

The debugger now shows the results of simple String(), Error(), and DebugString() method implementations in the Variables pane. It supports methods with a single return statement without calls.

Presentation of time.Time and net.IP in the Variables pane

Better presentation of special types

GoLand 2019.2 displays the value of struct derived from time.Time, time.Duration and net.IP types in a human-readable format in the debugger’s Variables pane.

Select decimal format in the settings

Default format for integers

Choose how to display integer variables in the debugger by default: in binary, decimal, or hex format. Set the format in Settings/Preferences | Build, Execution, Deployment | Debugger | Data Views | Go.

Support for Go 1.13 features

Result of new number literals in the Console

GoLand 2019.2 supports number literals and signed integers as shift counts. These changes are related to the steps we’re making towards Go 2. Head to the official Go blog to learn more.

GoLand’s code highlighting will alert you to any mistakes, and it will correctly show you the output in the Console.

Read this article to learn more about the new Go 1.13 features and how GoLand 2019.2 supports them.

Custom Postfix Completion templates

Using custom .forrev template

GoLand 2019.2 lets you create your own custom Postfix Completion templates.

Navigate to Settings/Preferences | Editor | General | Postfix Completion, click +, select Go, define your template, and choose the scopes where the template will be applicable.

To learn more about creating custom templates, see this article.

In addition, you can find new predefined Postfix Completion template — .aappend. It prepends an expression with a built-in append function call and assigns its result to this expression.

Quick-fixes based on Change Signature

New quick-fixes in action

We have added many quick-fixes based on the Change Signature refactoring. For example, with the simple press of Alt+Enter, you can automatically infer and add a parameter to the function call, or add missing return parameters in a signature.

Extract Method refactoring with returns

Extract Method extracts code with return statements

The Extract Method refactoring now handles code with return statements. If the code always exits via returns, it will be extracted as is. However, if it contains execution paths without returns, the extracted method will have an additional boolean flag as a return value. The flag will be used to perform an early return on the call side.

Code Completion improvements

Code completion suggestions for a receiver member without a receiver

Code completion now provides suggestions for receiver members even if there’s no receiver. Receiver names like this or self are discouraged. As a result methods have different receiver names. This code completion feature allows you to ignore the difference.

Cleverer Go Modules and dep integration

Go Modules integration enables automatically

GoLand 2019.2 enables Go Modules/dep integration automatically when it detects that a project uses Go Modules or dep. Previously, it disabled GOPATH indexing and showed only a notification about enabling Go Modules/dep integration. We noticed that was not enough though, because it was easy to miss or ignore the notification and thus get a project in a semi-configured state.

If this doesn’t work for you, you can disable the integration manually in Settings/Preferences | Go | Go Modules (vgo) at any time.

Code inspections

Inspection warns about redundant type conversions

Redundant type conversions

A code inspection called Redundant type conversions helps you keep your project more readable and neat. It warns you about redundant type conversions that can be omitted.

IDE warns about a non-negative integer constant in the editor

Validation of slice indices in literals

We’ve added validation of slice indices in composite literals! This means that the editor will warn you that your index must be a non-negative integer constant before you compile your project.

Code Editing

code highlighting, an inspection, and smart editing in action

Support for escape sequences

Support for escape sequences in string literals is fully equipped with:

  • Code highlighting.
  • An inspection that will warn you about potential problems.
  • Smart editing that understands the location of escape sequences.
  • More precise spell-checking.

Also, formatting placeholders are now highlighted in a different color so you can more easily spot them in long strings. You can customize the color via Settings/Preferences | Editor | Color Scheme | Language Defaults | String | Escape Sequence | Valid. Or, for Go only, go to Settings/Preferences | Editor | Color Scheme | Go | String | Valid escape.

Using Fill Fields via code completion

Fill Fields action

It is now easier to fill the fields of structs. First, you can choose which fields you want to fill in a dedicated window. Second, generated values can now be edited. Finally, this action is now available via Code Completion.

Using Fill Fields via code completion

Improved Extend Selection

Extend Selection now extends the code in a semantically correct way, from a line to a block of code separated by empty lines (instead of selecting the whole method body).

UI enhancements

New | File dialog

Fresh look for New | File dialog

The New | File dialog has been turned into a popup with a list of all the possible options for a particular file type to create. Previously, you had to expand the list to choose an alternative, but now all the available options are immediately visible.

Plugins page

Improved Plugins page

Now GoLand shows the plugin details right away, without any need to open the plugin’s detail pages one by one. We’ve added more options under the gear icon, so you can disable or enable all the downloaded plugins all at once. The Update button is now placed near the plugin name in the Installed tab. The Updates tab is gone as it isn’t necessary anymore.

Difference between an old Find tool window and the new one

Tidy Find tool window

In the Find tool window, we have grouped together some rarely used icons and removed others altogether.

Handy general changes

Select Recently Viewed Files scope

More Scope chooser options

New scopes such as Recently Changed and Recently Viewed Files, Files in Previous Search Result, and Selection are all now added to the Scope chooser. You will also be able to select the Data Sources scopes. In addition to this, we’ve added an ability to select a scope for Rename refactoring. Double press Shift+F6 to invoke the Rename refactoring window, and choose the scopes where the renaming will be performed.

Settings of Move Caret to Next Word action

New option to control caret movement

The default behavior of the Move Caret to Next Word action in GoLand 2019.2 has changed: the IDE now moves the caret to the end of the current word. However, you can adjust it as you see fit. Go to Settings/Preferences/Settings | Editor | General and select where the IDE should place the caret: at the end of the word, at the beginning of the next word, or even between both boundaries.

File size, date and time of modification in the Project View

More info in the Project View

Toggle In-place Descriptions under the View menu to get a preview of the file size, and date and time modifications in the Project View.

Version control improvements

File size, date and time of modification in the Project View

Commit from the Local Changes

GoLand 2019.2 provides a way to commit directly from the Local Changes.

Now while working on a commit, you can browse through the source code, view the history for a specific file, view the diff for the file in the same area as the commit, or use the other features of the IDE.

To enable this functionality and commit from the Local Changes without a dialog, go to Settings/Preferences | Version Control | Commit Dialog and select the checkbox Commit from the Local Changes without showing a dialog.

Adding a file to .gitignore via context menu

Improvements for .gitignore files

GoLand correctly highlights all the ignored files and offers code completion suggestions for file and folder name. You can now quickly add a file to .gitignore using the context menu from the Local Changes tab of the VCS tool window: right-click it in the Unversioned files group and select Add to .gitignore.

Abort Cherry-Pick option via context menu

Abort Merge option

We've added an Abort Merge option that will be available in the Branches popup when there is an ongoing merge. This is the future many of us have dreamed of, where you don’t need to switch to the terminal anymore to abort things.

Select Hash column

Customizable VCS Log columns

Click on the eye icon to choose the columns to display in the Log tab, select the Show Columns item from the context menu and choose the columns you want to see: Author, Date, or Hash.


Path completion for Shell Script

Shell Script support

GoLand 2019.2 provides support for shell scripts, including word and path completion, Quick documentation preview, and even text-based rename.

On top of that, we’ve added integrations with Shellcheck, and shfmt.

The debugger displays int as binary via View as action

Kustomize support for Kubernetes

With the Kubernetes plugin, GoLand 2019.2 provides editing support, code completion for keys and paths, many inspections, and the Rename refactoring. It will also let you navigate from a declared path to the associated packages or files in the project view for Kustomize resource files.

The services tool window with the file system of the running Docker container

Browser for Docker container file system

Now you can view the file system of the running Docker container. The file system is displayed in the File tab of the Docker node in the Services tool window.

Web development

Propagate to destructuring declaration intention in action

Smart intentions for JavaScript and TypeScript

With the new Propagate to destructuring declaration intention, you can replace an extra variable if it’s possible with another destructuring. To remove a destructuring completely, use the intention action called Replace destructuring with property or index access.

The IDE will now warn you if a boolean expression in a condition has some unnecessary parts and will suggest simplifying it.

Grouped and excluded dynamic usages in the Refactoring Preview tool window

Improved Rename refactoring for JavaScript

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.

Code completion for components

Improved support for Vue.js

Using Vuetify or BootstrapVue in your Vue.js application? Code completion for components and their props from these and some other Vue component libraries is now more precise. This was made possible by a new approach we’ve adopted to work with these libraries in the IDE.

2019.1 Nov 21

Memory, CPU, Mutex, and Block profilers

Using Memory profiler in GoLand

GoLand has expanded its tooling support by integrating Memory, CPU, Mutex, and Block profilers. You can start profiling your application right from the IDE, and then review the analysis results in a dedicated tool window (View | Tool Windows | Profiler).

To run the profiler, click the new Run with Profiler button and choose the required configuration in the navigation toolbar. Alternatively, select any of new actions in the run menu, which appears when you click on the run icon in the left gutter.

To get a better understanding of the possible performance issues in your code, sort the results by available metrics for each particular profiler type; use the Flame Chart, Call Tree and Method List tabs; or even navigate to the source code to inspect the issues.

Smart Step Into

Smart Step Into in action

Debugging a chain of calls and nested method calls is easier with the new debugger action, Smart Step Into. It lets you step into arbitrary calls in an expression, automatically stepping over the methods that you are not interested in.

For example, when debugging code like fmt.Printf("My name is %s, I am %d!", me.FullName(), me.Age()), you can opt to specifically step into Age().

To invoke Smart Step Into, press Shift+F7 or select Smart Step Into in the Run menu.

To learn more, see Debugging in GoLand – Improvements in 2019.1.

New refactorings

Extract Interface refactoring dialog

Extract Interface

The Extract Interface refactoring helps you quickly create a new interface based on the selected type. To invoke it, call up Refactor This, press Ctrl+Alt+Shift+T on Windows/Linux or ^T on macOS and choose Extract Interface in the pop-up menu.

The refactoring dialog shows a list of suggested members to be transferred to the new interface. You can specify a name for the interface and choose the file, directory, or package where it should be placed. If the type already implements any interfaces, it will be automatically excluded from the list.

To learn more, see Refactorings in GoLand — Extract Interface.

Rename refactoring asks to rename method specifications and all implementations in the interface or only current method

More capable Rename

The Rename refactoring also helps rename methods declared in interfaces. When renaming such methods, GoLand will offer to rename their implementations as well.

The Refactoring Preview panel in the Find tool window lets you see what the current refactoring will affect, with usages grouped by their type and location in the project.

Nilness Analyzer

Go gives us many ways to make the zero value useful, but the more opportunities we have, the easier it is to fall into a trap.

Our brand new Nilness Analyzer is a set of code inspections designed to instantly detect whether variables might have nil or not nil values in a variety of cases, and alerts you about potential errors and problems.

To learn more, see Nilness Analyzer Inspection.

Debugger improvements

Switching between goroutines and threads in the debugger

Goroutines instead of threads

The debugger output now displays goroutines instead of threads. Switch between them, quickly navigate to standard Go libraries, and get more information about how your code is being executed.

Also, use Copy Stack (right-click on the goroutine list) to copy the whole frame stack to the clipboard.

The debugger displays int as binary via View as action

View int as binary, decimal, or hex

You can now choose whether to display int variables in the debugger views as binary, decimal, or hex. Right-click a variable and select the appropriate or preferred option under View as.

Debugging with Run to Cursor as mouse gesture

Run to Cursor as mouse gestures

The Run to Cursor action is now available by clicking on a line number while debugging. Hover over a line to highlight it. Click a line number to Run to Cursor.

Debugging windows minidumps on macOS

Support for minidumps

In addition to exploring core dumps, now you can also open and analyze windows minidumps right in the IDE. Like with core dumps, it’s as easy as selecting Run | Open Core Dump.

To learn more, see Debugging in GoLand — Windows Minidumps.

Run/Debug configuration window with new sudo checkbox

Run Go configurations with sudo

Run/Debug Configurations can now be run with sudo. It allows you to debug applications which require privileged operations as a user.

Support for theme customization

GoLand in new Dark Purple theme

Say hello to the brand new UI themes! Dark Purple, Cyan Light, and Gray themes are now available, via plugins.

Not enough purple? Too boring? Too fun? No problem any more! Starting with 2019.1, all IntelliJ-IDEA-based IDEs get fully customizable colors of all their UI elements. You can literally change the color of anything!

We've made this customization pretty easy to do. Learn how to create and share your own themes in this tutorial.

Install any Go SDK right from the IDE

GoLand's welcome screen with the new option to download and install any
                            required version of the Go SDK

When creating a new project in GoLand, there is now the option to download and install any required version of the SDK, including Beta and RC versions. You don’t have to leave the IDE or go surfing through the Web anymore.

As soon as the selected SDK version is installed, GoLand will notify you in the Event Log window.

Go Modules updates

Vendoring mode checkbox in Go Modules settings

Vendoring mode

The Go Modules projects template gets a new Vendoring mode checkbox, which lets you use libraries from the vendor folder without any external dependencies or connection to the Internet. The same checkbox is also available via settings in Preferences | Go | Go Modules (vgo).

Code completion for non-imported modules

Completion for non-imported modules

GoLand provides code completion suggestions for all modules in the modules cache as you type. This means that, even if a module has never been imported and used in your project, GoLand is still aware of it.

New Intention Actions

Set of declaration intention actions

Set of declaration intention actions

We’ve added a set of intention actions to help you reformat declarations the way you want: add/remove parentheses to/from a declaration, merge a declaration up, split a declaration into two groups, by comma, and more.

For the complete list of available actions and their detailed descriptions, go to the Declaration section of Go in Settings/Preferences | Editor | Intentions.

Export intention action

Export intention action

A new Export intention action lets you export a private function, type, or field without switching between packages.

In addition, GoLand now resolves references to unexported symbols, but it will still notify you that it’s an error.

Handy general changes

Choosing Sublime Text keymap in settings

Sublime Text keymap

The new pre-configured Sublime Text keymap is available at Preferences | Settings | Keymap.

Note you can also use the pre-configured VS Code keymap, available via this plugin.

Recent Locations popu

Recent Locations popup

The Recent Locations popup (Cmd-Shift-E /Ctrl+Shift+E) is a new way to navigate around the project. It shows a list of recently visited/changed code locations as code snippets with a couple of lines before and after the location. To filter the results, start typing and jump matching piece of code.

Welcome screen with new project templates for web development

Project templates for web development

Project templates for web development, such as React App, React Native, HTML 5 Boilerplate, and Foundation, are available from the Welcome screen.

Export 'Code Style' settings to JSON option in settings

Export 'Code Style' settings to JSON

Now it is possible to export Code Style settings to JSON. This is in addition to the already available option of exporting to XML, available under Preferences /Settings | Editor | Code Style.

Version control improvements

'Uncheck all' checkbox for Partial Git in action

'Uncheck all' checkbox for Partial Git

The new Uncheck all checkbox for Partial Git commits (git add -p) lets you uncheck all the code chunks at once, and lets you choose the ones you want to commit, too.

Fixup and Squash Into actions

'Fixup' and 'Squash Into' actions

The Log tab in VCS gets Fixup and Squash Into actions to create commits with the correct fixup! and squash! messages.

Also, you can now use the context menu on the Log tab to cherry-pick selected files from the commit.

New checkbox for incoming and outgoing commits in settings

Indication of incoming & outgoing commits

If you go to Preferences/Settings | Version Control | Git and select Mark Branches that have incoming/outgoing commits in the Branches popup, the IDE will indicate if the incoming and outgoing commits are available for individual branches.

Author initials in annotations

Author initials in annotations

In addition, the IDE gives you a choice to display the initials of authors instead or their full names in VCS annotations.

Even more changes

Multiple defaults in switch code inspection
  • Multiple defaults in switch code inspection warns you about redundant default cases in a switch statement and lets you quickly navigate to the duplicated default.
  • The Duplicate names code inspection now notifies you if dot import introduces a duplicate.
  • In the Project view, the files and folders that are ignored now use olive-green to help you distinguish them from other files. You can modify the color of these in Preferences/Settings | Version Control | File Status Color.
  • Settings of JetBrains-made plugins are searchable in the Preferences/Settings dialog.
  • Copy & paste text to the Blank Diff window by dragging a file to it. Alternatively, you can do the same through file navigation.

Web development

Using JavaScript destructuring

Destructuring in JavaScript and TypeScript

Destructuring lets you unpack values from arrays and objects into variables using a very concise syntax.

GoLand 2019.1 delivers a new set of refactorings, intention actions, and quick-fixes to help you start easily destructuring objects and arrays in your code.

Convert function with Promise to async/await

Convert Promise to async/await

The new Convert to async function intention action automatically changes a function that returns a promise with .then() and .catch() calls to an async function that uses the async/await syntax. This is available in TypeScript, JavaScript, and Flow files. Simply press Alt+Enter on the name of the function you want to convert.

Highlighting for failed line in test

Highlighting for failed line in test

GoLand lets you quickly determine where the problem with the failed test has occurred. IDE highlights related code in the editor, and on hover, you’ll see the error message from the test runner.

This works with Jest, Karma, Mocha, and Protractor.

Updated docs and browser compatibility

Updated docs for CSS

The documentation (F1) for CSS properties, HTML tags, and attributes shows actual descriptions and information about the browser support from MDN.

Also, now you can use a new compatibility inspection via Browser compatibility in Preferences/Settings | Editor | Inspections – CSS. Simply select the minimum browser version you want to target.

Databases updates

New supported databases
  • Greenplum, Vertica, and Apache Hive databases are supported.
  • The Remember password feature now has two options for storing passwords: Forever and For session.
  • We've completely reworked the connection dialog.
  • New keep-alive and auto-disconnect options.
  • The filter in the data editor suggests the clipboard.
2018.3 Nov 21

New Change Signature refactoring

Change Signature refactoring in action

The new Change Signature refactoring gives you many ways to modify a function, method, or method specification signature in just a few clicks!

You can easily change their names and add, remove, reorder, and rename parameters. When you refactor a method specification, GoLand will even ask you if you want implementations to be updated as well.

To learn more, see the detailed blog post on how to use Change Signature efficiently.

Improved refactorings

Problems Detected dialog

Rename refactoring

The Rename refactoring gives you an insight into the potential conflicts that might be introduced by the renaming, if any.

Inline refactoring highlights code after applying

Inline refactoring

GoLand now highlights inlined code after applying the Inline refactoring, to help you catch what has actually happened.

Debugging GAE apps

Debugging Google App Engine application

GoLand now lets you easily run and debug Google App Engine applications locally.

We’ve also added a new App Engine project template.

To learn more, see debugging Google App Engine applications.

Core dumps support

Exploring core dumps in the Debugger pane

Sometimes standard debugging instruments fail to help you understand what’s wrong with the code. This is where core dumps come to the rescue!

GoLand makes exploring core dumps easier without any third-party tools, because all you need to do is to select Run | Open Core Dump.

To create crash dumps automatically, just enter GOTRACEBACK=crash in the Environment field in the Run configuration settings.

Note that core dumps are available only on Linux machines by default. However, you can analyze memory dumps on any flavor of macOS, Windows, or Linux.

Testify support

Run suites from the editor

Now you can run suites and methods as regular test functions, directly from the editor.

The Comparison Failure window helps explore diffs between expected and actual values for failed assertions.

In a related change, Empty test file, Test for function, Tests for file, and Tests for package are available via the Generate popup menu.

Code inspections

Unhandled Error warning in the editor

Unhandled Error

The Unhandled Error code inspection alerts you about functions or methods that return an error whenever the error isn’t being checked.

Unreachable Code warning in the editor

Unreachable Code

The Unreachable Code inspection detects parts of code that can never be executed.

Add format string argument

Add format string generates a placeholder via popup

The Add format string argument intention action generates a placeholder for any provided expression via a popup. It inserts the placeholder into a format string and passes the expression as an argument for the placeholder.

Also, you can enable code folding for format strings that will replace placeholders with the corresponding arguments.

Generate intention actions

Generate Constructor adds functions

Generate Constructor

The Generate Constructor intention action generates functions for creating values of the struct type.

Generate Constructor, as well as Generate getter/setter and Generate getter and setter are available via the Generate popup menu.

Generate getter and setter adds template

Generate getter and setter

The intention actions Generate getter/setter and Generate getter and setter now create boilerplate code and let you customize the pointer/non-pointer receiver type and its name.

Code completion

Code completion provides a set of functions which accept value of type as the first argument

GoLand 2018.3 adds method-like completion for functions. When you have value t of type T and write t.Foo, you can look through functions that accept value of type T as the first argument.

Invoke the Basic completion (Ctrl + Space + Space) twice to see all of the available completion options.

Code editor

Complete Current Statement inserts trailing comma

Complete Current Statement

Complete Current Statement now inserts the required trailing comma automatically in any composite literals (such as struct, slice, etc.) and puts the caret on the position of the next statement. Just press Cmd + Shift + Enter on macOS or Ctrl + Shift + Enter on Windows/Linux.

Navigation between shadowed and shadowing methods

Spot shadowed/shadowing methods

New gutter icons let you better spot shadowed/shadowing methods of embedded types. You can also navigate back and forth in one click, or by pressing Cmd+U on macOS or Ctrl+U on Windows/Linux.

Excluding a specific set of files from the formatting actions

Don't format this set of files

In GoLand 2018.3 and further versions, you can exclude a specific set of files from the code actions Reformat code, Optimize imports, and Rearrange.

Go templates (html/template)

Code completion and Rename refactoring in html/template

As you work with Go templates (html/template), enjoy code completion, find usages, the Rename refactoring, and improved code formatting.

Debugger updates

Evaluate Expression warns about invalid array index and provides code completion

The debugger provides code completion, inspections, and quick-fixes for the Evaluate Expression dialog and the Watchers panel.

Support for Mozilla rr

Debugging with Mozilla rr

We’ve added support for Mozilla rr in the debugger on Linux. It records program executions until you see a failure, so that you can then replay the failing execution as many times as you need under a debugger.

As soon as you install Mozilla rr, everything works in a click. Put a breakpoint and choose the Record and Debug option from the Run/Debug gutter icon in the editor. This action opens the Debugger tab in the Run window with a dedicated Rewind button, which allows you to run the program backwards until the previous breakpoint is reached.

Diagrams support

Go module dependencies diagram

Diagrams allow you to visualize and explore:

  • Go module dependencies (available only in the context menu of a go.mod file).
  • Imports and exports in-context in JavaScript and TypeScript projects.
  • Tables and their relationships in Databases and SQL.

To learn more, see this blog post about diagrams support.

Search & navigation

Search Everywhere popup shows search results

Improved Search Everywhere popup

The Search Everywhere popup (Double Shift) has a new UI and works faster thanks to an asynchronous approach.

It also provides quick access to Go to type, Go to file, Go to symbol, and Find. Use the TAB key to switch between them.

Searching multiline code snippet via Find in Path dialog

Find and Replace in Path dialogs

The Find in Path and Replace in Path dialogs are better at supporting multiline code snippets.

Multiline TODO comments

Multiline TODO in Go project.

GoLand 2018.3 supports multiline TODO comments for Go, JavaScript, TypeScript, CSS, and SCSS.

GitHub Pull Requests

GitHub Pull Requests shows searching results by state:close and RP description

The new GitHub Pull Requests tool window shows all pull requests from GitHub with their descriptions, current labels, changed files, and assignees. There, you can search by state, assignee, author, after, before, or use sorting. The IDE also helps you create a new local branch or open a pull request on GitHub. To open a new tool window, select View Pull Requests in the menu VCS | Git.


--pull in Build options field in the Dockerfiles run configuration

Docker plugin

You can now use CLI options for the build part: in the Dockerfiles run configuration, you will find the new Build options field. For now, the following CLI options are supported: cache-from, cpu-shares, cpuset-cpus, force-rm, label, memory, memory-swap, shm-size, no-cache, pull, quiet, and rm.

Code completion in Helm template

Kubernetes plugin update

As you work with Helm resource template files, enjoy code completion, the Rename refactoring, code inspections, and quick-fixes.

For more details, please read this blog post.


High-contrast theme

We strive to make our IDEs accessible to everyone, and this update takes a big step in that direction.

We’ve added new a High-contrast theme, which can be accessed using the drop-down list from the theme options under Settings | Appearance & Behavior or just press Ctrl +  `.

Also, the IDE gets better support for screen readers. GoLand now allows line numbers, VCS annotations, breakpoints, and other gutter icons to be read by a screen reader.

JavaScript and TypeScript

Autoimports in JavaScript

Autoimports in JavaScript

GoLand now automatically adds imports not only for symbols defined in your project, but also for symbols from the project’s dependencies.

Parameter hints in JavaScrip

Parameter hints in JavaScript

As you may know, we have parameter hints in Go, TypeScript, and SQL, so they've come to JavaScript as well.

The inspection notifies that method if null or undefined

Better 'null' and 'undefined' check

The inspection Object is null or undefined notifies you when you get a TypeError because a method is invoked on a value that is undefined or null, or it is passed to a function, or its property is used.

Code completion in package.json

Completion in package.json

GoLand provides suggestions for the latest version, as well as previous ones for the dependencies in package.json.

Cassandra database support

Cassandra database support

Thanks to our wonderful colleagues on the DataGrip team, GoLand now supports Cassandra databases.

Even more changes

Reworked Plugins page
  • The Attach action is available via the Open Project popup. It lets you attach a directory to already opened projects. Click File | Open, and choose the project you want to attach.
  • Drag files and projects to the Welcome screen to open them.
  • The Activity Monitor shows how much CPU the various subsystems and plugins are consuming: Help | Activity Monitor.
  • The Plugins page in Settings | Plugins has been completely reworked, including all the functionality and UI.
  • Indexing is now significantly faster.