Metals v0.9.1 - Lithium

July 1, 2020

Tomasz Godzik

Tomasz Godzik

We're happy to announce the release of Metals v0.9.1, which focused on fixing issues with the recently released Scala 3 support, Ammonite support and a couple of new features.

Commits since last release 287
Merged PRs 106
Contributors 16
Closed issues 49
New features 5

For full details: https://github.com/scalameta/metals/milestone/24?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab with the help from Lunatech along with contributors from the community.

TL;DR

Check out https://scalameta.org/metals/, and give Metals a try!

  • Ammonite support
  • New project provider
  • Worksheet dependency support
  • Multiline string improvements
  • Scala versions 2.13.3, 0.24.0, 0.25.0-RC2 support
  • Dropped support for Scala 0.23.0 and deprecated the 0.24.0-RC1 version.
  • Multiple build tool selection within a workspace

Ammonite support

Thanks to great work by alexarchambault we now support Ammonite script files. Ammonite enables you to create scripts that can easily be ran from the command line, without the overhead of setting up a build tool while still allowing you to download and use dependencies.

The support includes most of the LSP features such as diagnostics, completions, references, go to definition, but does not include running or debugging the scripts. This new feature works by starting an additional Ammonite BSP server that compiles the scripts and provides additional information about them such as Scala version or information about the added dependencies. You can change the default JVM parameters for the server such as -Xmx, which will limit the used memory in Metals settings. These can be added via your metals editor extension using the newly created metals.ammoniteJvmProperties setting. The Ammonite server can also be started and stopped manually using the new commands ammonite-start and ammonite-stop.

Each of the scripts first need to be imported into the Ammonite BSP server, which can be done manually by clicking on the pop up whenever a new script is opened or selecting automatic import at the start, which will import any open scripts automatically.

It's important to note that this is an early approach to Ammonite support, which might still require some improvements both on the Metals and Ammonite side. You can learn more about the new feature or join the discussion in the blogpost on the Scala contributors forum.

Some of the notable features of Ammonite scripts are:

  • Import other scripts: Metals provides completions to select existing files based on the filesystem information
//main.sc
import $file.hello-world
val greeting = hello-world.greeting

//hello-world.sc
val greeting = "Hello world!"
  • Import dependencies:
import $ivy.`com.lihaoyi::scalatags:0.7.0`
import scalatags.Text.all._

val rendered = div("Moo").render
  • Set Scala version:
// scala $scalaVersion

import scala.util.Properties

pprint.log(Properties.releaseVersion)

The Scala version is independent from any build tool used in the workspace and without specifying the exact version it will use the default Ammonite Scala version.

To learn more about Ammonite please visit the documentation website at https://ammonite.io.

Worksheet dependency support

In addition to Ammonite support, which will be useful to anyone interested in Scala scripting, we've also improved the support for Metals Scala worksheets. Thanks to the efforts of olafurpg in mdoc, which powers worksheets, users are now able to import dependencies directly inside of their Scala worksheet with completions and diagnostics working right from the start.

worksheet-imports

You can add them using the following syntax:

$ivy.`organisation::artifact:version`

For example:

$ivy.`com.lihaoyi::scalatags:0.9.0`

:: is the same as %% in sbt, which will append the current Scala binary version to the artifact name.

New project provider

Creating new Scala projects is usually a bit of work to get started, which is a problem for both beginners and experts alike. Normally you don't want to spend a lot of time figuring out the best setup for starting with a new technology or the language itself.

There are great tools like giter8, which is used in the sbt new command, that enables people to use already existing Scala templates found on Github such as https://github.com/scala/scala-seed.g8. The problem is when you don't use sbt or you don't know the exact template you want to use.

To address this, we've added an additional command called New Scala Project that enables users to reuse the same mechanism from the comfort of your editor. Firstly, you can choose from existing templates, either curated by the Metals team, ones existing on the giter8 wiki page or alternatively an entirely custom template. Then you can choose the exact location for the new project and the name. Afterwards, Metals will run giter8 to create the project and offer to open that new project.

new-project

The command is also available as a button in the welcome view of the Visual Studio Code Metals extension, which means it will be visible in case there are no imported projects in the current workspace.

The first curated templates were chosen by the team, however we are happy to include more so that it's easier for people to discover new amazing libraries or frameworks.

Multiline string improvements

There are two new quality of life improvements when it comes to multiline strings. Firstly, thanks to mlachkar we now automatically add stripMargin method invocation when using newline in a multiline string if that string uses | and has no existing stripMargin:

strip-margin

This behaviour can be disabled in Metals settings using metals.enableStripMarginOnTypeFormatting.

Another useful improvement coming from colineto is a new code action that can easily convert single string into the traditional multiline string with | and stripMargin at the end:

new-action

Multiple workspace build tools selection

Previously, Metals would only pick up a single build tool in a workspace even if in reality there were multiple available ones. To help with that we added a prompt to choose the desired build tool in workspaces with multiple build files.

An example situation where this is needed is when you have a project with both a build.sbt and build.sc, but the build.sc is what you use for your build definition. Previously if both were detected, it was automatically considered an Sbt workspace, however now it's possible to choose.

multiple-build-tool

In case of multiple build tools in single workspace you can see which one was used to import project in 'Metals Doctor' view. If you choose the wrong one, or change the main build tool later on, you'll need to remove the .metals/ directory to reset the decisions.

This great new feature was contributed by ckipp01!

Miscellaneous improvements

  • Fix run/debug in Maven workspaces.
  • Always run newest sbt version if none is specified.
  • Fix find references for Scala 3 on Windows.
  • Pick jvm targets with higher priority when using run/debug without specifying the exact build target.
  • Make breakpoints work properly in Scala 3 and in case of nested classes.
  • Exhaustive pattern matching in the case of sealed upper bound types.
  • Compile before renaming instead of showing an error.
  • Fix issue with symlinked source directories.
  • Fix missing references for synthetic companion objects.
  • Automatically add -J if it doesn't already exist to java properties when running or debugging.
  • Fix go to definition for JDK 11 library sources.
  • Keep modifiers when implementing abstract members.
  • Fix auto imports position when using package objects and multiple package definitions.
  • Fix issues in files with Scala 2.13 specific syntax like for example underscore numeric literals (val num = 100_000).
  • Always run Mill in interactive mode.
  • Improvements to hover in Scala 3 files.
  • Make sure auto imports are correct for Ammonite scripts

Contributors

Big thanks to everybody who contributed to this release or reported an issue!

$ git shortlog -sn --no-merges v0.9.0..v0.9.1
Tomasz Godzik
Scala Steward
Alexandre Archambault
Chris Kipp
Łukasz Trojanowski
Coline Thomas
Krzysztof Bochenek
Meriam Lachkar
bettyblue
Daniel King
Naoki Takezoe
Olafur Pall Geirsson
Win Wang
Martin Duhem
ag91
faizk
Łukasz Wawrzyk

Merged PRs

v0.9.1 (2020-07-01)

Full Changelog

Merged pull requests:

Metals v0.9.0 - Lithium

May 4, 2020

Tomasz Godzik

Tomasz Godzik

We are happy to announce the release of Metals v0.9.0, codename "Lithium", which main focus is introducing support for Scala 3 starting with versions 0.23.0 and 0.24.0-RC1. We also added support for Scala 2.13.2 and a number of other useful improvements.

Commits since last release 140
Merged PRs 45
Contributors 14
Closed issues 9
New features 3

For full details: https://github.com/scalameta/metals/milestone/13?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab with the help from Lunatech along with contributors from the community.

TL;DR

Check out https://scalameta.org/metals/, and give Metals a try!

  • Scala 2.13.2 and basic Scala 3 support
  • Improvements to the Bloop integration
  • Automatically add '+' on newline when inside a string
  • New Code action: "Import all missing symbols"

Basic Scala 3 support

For a couple of the last months we have been working on making Metals work with the Dotty compiler, which will become the new Scala 3. This effort included contributions to Metals, Bloop as well as to Dotty. Thanks to the great help from the Dotty compiler team, we now have an option to generate semanticDB files used for our internal indexes, which allowed some features to work without any changes to the core code. It is also important to mention that without jvican and his Bloop project, which already supports Scala 3, all this would have taken a much longer time.

That said, there are some issues that are lacking in the Scala 3 support that are available for 2.x versions. Most notably, we are still missing all of the more advanced completions, filtering and sorting of completion items or auto imports. There are also some possible issues connected to optional braces and top level methods features. In the upcoming months we are planning to address most of these issues and implement the lacking features.

You can find missing features in the feature requests repository and currently known bugs in the main Metals repo.

The first supported versions will be 0.23.0 and 0.24.0-RC1, which are the latest stable and the latest release candidate respectably. We plan to always support the latest stable and release candidate until there is a more stable release cycle for Scala 3.

Please do report any issues you encounter, especially connected to some new Scala 3 features, which will be an immense help to the team.

Improvements related to Bloop/Metals integration

There have been multiple reported issues in the last weeks about hanging compilation, which can make the Metals workspace hard to use. Our top priority has been figuring out all the possible issues both in Metals as well as in Bloop. Thanks to some fixes done by jvican, and some work on the Metals side on the Bloop integration we're hopeful that some of the issues are becoming less frequent. These fixes are included in this release.

We also reworked the Metals tree view to highlight some commands that a user can use to fix their workspace as well as added two new commands:

  • Clean compile workspace - clean compile the whole workspace - might be needed in case of broken compiler caches.

  • Restart Bloop server - restart the Bloop build server, which should help with the cases where compilation would hang.

    reworked-tree-view

Even if those commands help, do not hesitate to report any issues. We are also monitoring the situation ourselves and investigating all problems encountered.

Automatically add '+' on newline inside a string

The Metals team was recently joined by mlachkar, an engineer from the Scala Center, who already contributed a number of features and bug fixes to the project. Thanks to her, we can now easily enter a newline inside a single line string and that string will be correctly split with an additional +.

split-line

Code action to import all missing symbols

Previously, it was only available to import one symbol at a time in case of missing imports. Thanks to colineto we now have the ability to import everything in bulk for every unambiguous import available. Unambiguous in this case meaning that there is only one possible import to choose from.

import-all

Miscellaneous improvements

  • Added an option to ignore .scalafmt.conf creation message.
  • Fixed hanging while debugging if workspace had errors.
  • Fixed issue with folding in non 2.12.11 workspaces.
  • Turn off "Go to parent" code lenses by default due to performance problems in large workspaces.
  • Fixed false parsing errors in 2.13.x workspaces.
  • Added date string to metals logs.
  • Fixed issue with additional src directories being created automatically.
  • Fixed "Go to implementation" to work with local aliases.
  • Fixed auto-import issue in package objects.

Contributors

Big thanks to everybody who contributed to this release! We had a lot of new contributors doing some really exemplary work.

$ git shortlog -sn --no-merges v0.8.4..v0.9.0
Ayoub Benali
Tomasz Godzik
Scala Steward
Chris Kipp
Coline Thomas
Meriam Lachkar
Win Wang
Elie Poussou
Krzysztof Bochenek
Olafur Pall Geirsson
Aleksei Alefirov
Naoki Takezoe
Nathaniel Fischer
Tomasz Pasternak

Merged PRs

v0.9.0 (2020-05-04)

Full Changelog

Merged pull requests:

Metals v0.8.4 - Cobalt

April 10, 2020

Tomasz Godzik

Tomasz Godzik

We are happy to announce the release of Metals v0.8.4, which will most likely be the last 0.8.x version.

Commits since last release 174
Merged PRs 55
Contributors 9
Closed issues 13
New features 3

For full details: https://github.com/scalameta/metals/milestone/22?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab with the help from Lunatech along with contributors from the community.

TL;DR

Check out https://scalameta.org/metals/, and give Metals a try!

  • navigating to parent method
  • support for launch.json
  • new "Create new symbol" code action
  • miscellaneous improvements

Navigating to parent method

Metals will now calculate if any definition of a method in the current file overrides another method, in which case it will show a new lens next to the method's position. Once clicked, the user will be able to go to the super method. Lenses also link to methods in external dependencies and are displayed in files from libraries. For this new feature to work make sure that you enable code lenses in your client.

Screenshot 2020-03-10 at 09 24 41

If they are found to be disturbing your workflow they can be easily disabled via the metals.superMethodLensesEnabled configuration option - they are enabled by default. For example in Visual Studio Code:

Screenshot 2020-03-09 at 16 24 21

These new lenses should be quick to calculate but if you notice significant slowdown you can also disable them, since when disabled they are not only not displayed but also not calculated at all.

There is also an exposed server command goto-super-method that can be mapped and used through shortcut in Visual Studio Code.

Screenshot 2020-03-10 at 09 38 49

It is possible to also navigate the whole inheritance hierachy at once using the new super-method-hierarchy command.

super-hierarchy

This new command can be invoked on a method definition. It calculates super method hierarchy and if more than one position is found it displays a quickPick window (same as the new scala file feature) which displays all super methods and allows a user to select one and jump to its definition.

As an example in Visual Studio Code it can be bound to a shortcut this way:

Screenshot 2020-03-10 at 09 48 55

Thanks to kpbochenek from VirtusLab for this new feature!

Support for 'launch.json'

Previously, it was only possible to launch main classes or tests via code lenses that would appear above a particular class. Now, we add a way for a user to be able specify the name of the the class or test to run. We will then automatically try to detect the build target, which that class/test belongs to and run it. In this release, we also add a way to specify the main class arguments.

launch_debug3

While this will be primarily useful for the Visual Studio Code Metals extension, it will also make it easier for other editors that support the Debug Adapter Protocol. To obtain the uri needed for starting a debug session users can now execute the debug-adapter-start command with params:

  • for main class
{
  "mainClass": "com.foo.App",
  "buildTarget": "foo",
  "args": ["bar"]
}
  • for test class
{
  "testClass": "com.foo.FooSuite",
  "buildTarget": "foo"
}

buildTarget is an optional parameter, which might be useful if there are identically named classes in different modules. A uri will be returned that can be used by the DAP client.

More information about adding support for debugging is available here.

This awesome new feature was contributed by alekseiAlefirov from VirtusLab.

New 'Create new symbol...' code action

Previously we would propose to import a symbol (if available) in response to "missing symbol" errors. Now, thanks to gabro, we also propose to create a new class, case class, trait or object.

2020-03-23 17 49 31

This might be useful when sketching out a domain model and should improve user experience for fast prototyping.

Miscellaneous improvements

  • package is no longer added on imports from package objects
  • if user right clicks on a file in Visual Studio Code the option for New Scala file also shows now the same as for directories
  • a multiline string can now be formatted exclusively when using format selection on that string
  • added in ... to signify truncation in worksheets
  • fixed hover on Scala App trait and several other cases that showed up on Scala Play projects
  • messages about upgrading Scala versions are now more valid to the user
  • references in a file are sorted before showing them
  • better cursor position when creating new files using the New Scala file command
  • added "case class" option in NewFilesProvider

Contributors

Big thanks to everybody who contributed to this release!

$ git shortlog -sn --no-merges v0.8.3..v0.8.4
Olafur Pall Geirsson
Chris Kipp
Aleksei Alefirov
Gabriele Petronella
Tomasz Godzik
Krzysztof Bochenek
Alexandre Archambault
Scala Steward
Martin Duhem
Tomasz Pasternak
Łukasz Wawrzyk
Meriam Lachkar
duianto

Merged PRs

v0.8.4 (2020-04-10)

Full Changelog

Merged pull requests:

Metals v0.8.3 - Cobalt

March 19, 2020

Tomasz Godzik

Tomasz Godzik

We are happy to announce the release of Metals v0.8.3, which main purpose is adding support for the new Scala version, 2.12.11. Additionally, we included a couple of recent fixes.

Commits since last release 61
Merged PRs 18
Contributors 9
Closed issues 14
New features 1

For full details: https://github.com/scalameta/metals/milestone/21?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab with the help from Lunatech along with contributors from the community.

TL;DR

Check out https://scalameta.org/metals/, and give Metals a try!

  • support for Scala 2.12.11
  • recent minor improvements

Miscellaneous improvements

  • fix bug where worksheets got stuck evaluating forever
  • fix issue where Metals would incorrectly prompt about a Bloop version change
  • fix a bug where rename symbol produced invalid code for class hierarchies using generics
  • ignore return type when renaming overriden methods and fields
  • fix bug where docstrings for workspace sources returned stale documentation
  • goto definition now works for standalone source files, even if the build has not been imported
  • fix issue with string alignment when multiple multiline strings were present in a file

Contributors

Big thanks to everybody who contributed to this release!

$ git shortlog -sn --no-merges v0.8.1..v0.8.3
Tomasz Godzik
Olafur Pall Geirsson
Chris Kipp
Krzysztof Bochenek
Tomasz Pasternak
Win Wang
Łukasz Wawrzyk
Lorenzo Gabriele
Rikito Taniguchi

Merged PRs

v0.8.3 (2020-03-20)

Full Changelog

Merged pull requests:

Metals v0.8.1 - Cobalt

February 26, 2020

Tomasz Godzik

Tomasz Godzik

We are excited to announce the release of Metals v0.8.1. This release includes a large number of bug fixes and some new features.

Commits since last release 313
Merged PRs 100
Contributors 19
Closed issues 52
New features 2

For full details: https://github.com/scalameta/metals/milestone/19?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab with the help from Lunatech along with contributors from the community.

TL;DR

Check out https://scalameta.org/metals/ and give Metals a try!

  • insert missing abstract members
  • new file provider
  • enable rename preview for Visual Studio Code
  • debug and run working in Emacs

Insert missing abstract members

Thanks to yet again amazing work by tanishiking, we now support the quick fix code action for implementing abstract class members. This code action is available in case of errors and works in the same way as the recent "Implement all members" completion. It will add any missing abstract members at the top of the class with the default implementation of ???.

action

New file provider

In the last release we added support for worksheets, which are an easy way to quickly evaluate some code. To create a new worksheet you need to create a file with the extension .worksheet.sc, which was not that easy to figure out. To fix that situation, thanks to alekseiAlefirov, we now have a menu to create different types of new files including classes, traits, object, package objects and of course worksheets. At this time it's only available in the Visual Studio Code and coc-metals extensions.

new-file-provider

You can also just use the command Metals: New Scala File, which will use the current file's directory and create the new file there. And additionally, when using a relative path like a/b/C Metals will create all needed directories and add a proper package declaration to the new file.

Enable rename preview for Visual Studio Code

Rename previews were added in the last Visual Studio Code release, which enable users to see what will be changed when a rename is executed. Due to optimization and UX reasons Metals renamed symbols in closed files in the background without informing the editor. However, this also causes the previews to be misleading, since they might not be complete.

To fix that situation we now send all the files to VS Code, which then is able to display the preview. We do it, however, for up to 300 files, which threshold was experimentally estimated. When the number of files reaches over that number, we revert to the old behavior of not opening closed files. The reason for this is that in some cases for larger numbers of files the editor could hang and become unresponsive.

Debug in Emacs

In the last release run and debug support was only available for Visual Studio Code, but thanks to amazing work by the contributors it is now possible to use it in Emacs via lsp-mode's metals settings and dap-mode.

Other changes

This release includes mostly fixes and minor features, which is due to the large scope of the last one. We concentrated this last month on stability and making sure everything is up to scratch. Those minor changes included:

  • use bloop.export-jar-classifiers property when importing the build from sbt
  • ignore bad compiler options passed by users in order not to break completions
  • add an override for the Bloop plugin version and promote it to LSP settings
  • fix onTypeFormatting when used in top level multi-line strings
  • fix issues when go to implementation resolves local symbols
  • change the non-fatal jar error to debug rather than log warning
  • add support for worksheets without a build target by defaulting to Metals Scala version
  • rename file only if the renamed symbol is directly enclosed by a package
  • fix exhaustive match completion on Java enums
  • use workspace level Gradle wrapper if present for bloopInstall
  • fix onTypeFormatting issue with multiple pipes on a line
  • fix rename issues with backticks
  • add documentation on how to use proxies and mirrors

Contributors

Big thanks to everybody who contributed to this release!

Again, we have some new contributors and a lot of returning ones!

$ git shortlog -sn --no-merges v0.8.0..v0.8.1
Olafur Pall Geirsson
Tomasz Godzik
Scala Steward
Chris Kipp
Gabriele Petronella
Rikito Taniguchi
Aleksei Alefirov
Jakub Kozłowski
Arthur McGibbon
Carlos Rodriguez Guette
Danil Bykov
Jakob Odersky
Joris
Martin Duhem
Ruslans Tarasovs
Win Wang
joriscode
Kei Sunagawa
Zainab Ali

Merged PRs

v0.8.1 (2020-02-26)

Full Changelog

Merged pull requests:

Metals v0.8.0 - Cobalt

January 10, 2020

Tomasz Godzik

Tomasz Godzik

We are excited to announce the release of Metals v0.8.0, codename Cobalt. This release includes a large number of new features and improvements, which have been under development since September 2019.

Commits since last release 772
Merged PRs 214
Contributors 19
Closed issues 84
New features 8

For full details: https://github.com/scalameta/metals/milestone/9?closed=1

Metals is a language server for Scala that works with VS Code, Vim, Emacs, Sublime Text, Atom and Eclipse. Metals is developed at the Scala Center and VirtusLab along with contributors from the community. Recently, Metals has also gained support from Lunatech with the contributions from @ckipp01. We are extremely grateful for the growing support from the community and businesses alike, which shows in the number of new contributions and their quality.

TL;DR

Check out https://scalameta.org/metals/ and give Metals a try!

  • run and debug for tests and main methods
  • go to implementations
  • rename symbol
  • first code action - import missing symbol
  • worksheet support
  • improvements for Bloop integration
  • better support for Vim via coc-metals
  • completion to add all abstract members
  • scaladoc auto completion on type /**

Debugging

It is now possible to run and test directly from VS Code using the new "Run", "Test", "Debug" and "Debug test" buttons. The debug buttons support debugging with breakpoints. It's possible to insert breakpoints in Java and Scala sources for both workspace sources as well as library dependency sources.

debug

To support other editors please take a look into the documentation on the Metals website.

Known breakpoints limitations we are working on:

  • debugging is only supported in VS Code at this moment, we hope to increase the editor support in the future. To support debugging, editors need to implement the Debug Adapter Protocol
  • breakpoints may not work as expected in all source locations (example: inner classes, ambiguous names, lambdas). Please share your feedback by reporting issues!

Navigation

Go to implementations

Metals now implements the textDocument/implementations LSP endpoint, which enables all supported editors to display a list of all implementations of abstract classes or members.

implementations

Finding implementations also works for symbols outside of the workspace, at the price of a small performance penalty for the first invocation.

The work done for this feature was also instrumental for implementing the Rename refactor (see below).

Refactor

Refactoring support is one of the most requested features in Metals. In this release, we started by implementing the most commonly used refactors: rename and import missing symbol.

We plan to add more common refactors along the way. Make sure to check out the ones that have already been proposed and consider suggesting other refactors that are essential in your development workflow.

Rename symbol

Thanks to the implementation of the Go to implementations feature, we were able to work on a proper rename for any workspace symbol that will rename all occurrences of a symbol even if that symbol is a part of a class hierarchy.

rename

There are a couple of cases in which rename might behave differently based on the particular symbol being renamed:

  • renaming an overriden symbol will rename all occurrences for both parent and all children overriding that symbol
  • java symbols are not renamed
  • renaming "hashCode", "unapply", "unary_!", "!" is not supported, since they change the semantics
  • methods starting with : can only be renamed to ones with the same first character to make sure code compiles afterwards
  • renaming apply will change all occurrences with just () to a full name .newname()
  • if renaming a class with the same name as the file, the file's name will also be renamed
  • companion objects will also be renamed along with their companion classes

Import missing symbol

Another refactor that is commonly requested is the ability to fix a compilation error by auto-importing a symbol present on the classpath.

This was previously possible in Metals only during completions, but we were lacking what LSP calls a code action.

Code actions are context-sensitive actions that are proposed to the user in order to fix an error or to perform a relevant refactor.

Thanks to the work of @gabro we now have a basic architecture in place for supporting code actions and we were able to implement this feature.

missing-symbol

Worksheet support

Thanks to great work by @olafurpg and some additional refinements by @alekseiAlefirov, worksheets are now available in all supported editors.

Worksheets are a way to evaluate code in real time to test and prototype any new features in a simple way. To create a worksheet all that is needed is to create a file with the extension .worksheet.sc within the source directory of your workspace (like /src/main/scala) and Metals will take care of the rest.

There are two ways worksheets are implemented for different editors. One is with an additional extension to LSP called Decoration extension and it's used by Visual Studio Code and coc-metals.

Visual Studio Code:

worksheet

The other way worksheets are implemented for all other editors that don't support the Decoration extension is using workspace/applyEdits and comments with hover for larger results.

Sublime:

worksheet2

Build tools

In order to make the integration between Bloop and Metals a smoother experience, several new improvements are included in this release. There're based on feedback from users as well us our own experiences while working with Metals and should make the overall experience of importing the build and compiling much better.

SemanticDB is resolved inside Bloop

Metals requires the SemanticDB compiler plugin for a number of features to function properly. Because of that it was quite difficult to add it automatically in all supported build tools even if those supported Bloop itself. Perfect examples are Seed and Fury, which use Bloop to compile code, however adding a plugin automatically would require changes to their core code.

Currently, thanks to recent changes, Metals can send information about the SemanticDB version, which Bloop uses to automatically download and configure the SemanticDB scalac plugin. Thanks to that no changes in the build tool itself are needed. Particular changes in regards to build tools are:

  • Gradle - predef script code used in automatic import is now simplified a lot and works with even more customized workspaces. The only thing it needs to do is add the Bloop plugin and run bloopInstall, which can easily also be done manually by the user.
  • Maven - no manual configuration is now needed. To import automatically just the plugin is needed to be invoked with a setting for downloading sources.
  • Sbt - the metals-sbt plugin is now removed and the Bloop plugin is now added via automatically generated ./project/metals.sbt file and ran when imported automatically. Thanks to this solution it should be possible to reuse Metals compilation in the upcoming feature for offloading compilation in Sbt.
  • Mill - logic for adding semanticDB plugin is removed from Mill.
  • Fury, Seed - no changes were needed for the semanticDB integration and should work out of the box.

Switch to to using Bloop Launcher

Instead of using internal Metals logic, we now use the Bloop Launcher, which enables us to either connect to an existing Bsp server or start a new Bloop instance with the specified version if none is running. This greatly simplified the connection to Bloop and enabled us to work on further improvements.

Restart Bloop automatically if newer version is needed

Whenever Metals is started and connects to the Bloop build server it receives information about the version it is running. We compare that version to the one needed by Metals to make sure everything is properly working. If the current running version is older we offer to automatically restart it with the newer version. However, this may not work if Bloop was installed manually.

Automatically reconnect to Bsp/Bloop if connection is broken

There were numerous issues reported that the connection to Bps or Bloop was being lost, which causes Metals to behave erratically due to no compilation being run. To solve this, we now detect if the connection is closed and offer the user the option of automatic reconnection. This works both when the build server was down and when the connection was just interrupted. It should also solve the issues on MacOs with dropped connection.

Completions

Completion to add all abstract members

In the past when you were implementing an abstract member in a concrete class, you'd see the completion option to override the member. However, if you wanted to implement all of the abstract members, you'd need to do each one individually. Now you'll see a new completion option in the scenario to Implement all members which will implement all the members at once.

implement-all

Support scaladoc auto completion on type /**

Thanks to recent work by tanishiking Metals now supports auto completing scaladoc for method definition and class definition on typing /**. More details about it can be found in the pull request.

scaladoc

Better support for Vim via coc-metals

In order to better support the Vim experience with Metals, coc-metals extension was created which is an extension for coc.nvim, the most popular LSP client for Vim and Neovim. With this new extension comes a whole bunch of new features for Metals + Vim users.

  • automated installation
  • easier configuration options
  • easier workspace commands
  • embedded doctor
  • input box support
  • implementation of the decoration protocol (Neovim only)

coc-metals

Support for java 11

Thanks to @isomarcte we now also run all tests on JDK 11, which enables us to be more confident about the support for it. With some additional changes to the documentation we now can fully claim that support for JDK 11 is available.

Other changes

This version includes approximately 25% of the Metals git commit log, which makes it impossible to explain every possible improvement in these release notes. Some other features and fixes that we should mention are:

  • fix for handling abstract var overrides
  • add an empty line after the package declaration before import
  • sort auto-completed exhaustive matches by declaration order
  • encode the workspace path directory in build digests
  • tone down "No SemanticDB" warning
  • send Tree View update notification on first no-op compilation.
  • enable goToDefinition when cursor is at end of symbol
  • prioritize build targets with supported Scala versions.
  • add automatic formatting of multi-line stripMargin strings on paste
  • remove support for 2.12.7

Contributors

Big thanks to everybody who contributed to this release!

We had a lot of new contributors that provided us with some amazing new features and with some amazing quality.

$ git shortlog -sn --no-merges v0.7.6..v0.8.0
Ólafur Páll Geirsson
Tomasz Godzik
Marek Żarnowski
Scala Steward
Gabriele Petronella
Chris Kipp
Rikito Taniguchi
Szymon Świstun
David Strawn
Ayoub Benali
Aleksei Alefirov
Ashwin Bhaskar
Alexandre Archambault
Andy Czerwonka
Enrique Molina
Marc A. Saegesser
Soham Rohankar
Chris Birchall
kostafey

Merged PRs

v0.8.0 (2020-01-10)

Full Changelog

Merged pull requests:

Metals v0.7.6 - Thorium

September 23, 2019

Tomasz Godzik

Tomasz Godzik

We are excited to announce the release of Metals v0.7.6, which will most likely be the last release before the v0.8.0 one. This release includes support for new Scala versions (2.12.10, 2.13.1) and a couple of fixes. It also adds a new formatting on paste feature for multiline strings.

Metals is a language server for Scala that works with VS Code, Atom, Vim, Sublime Text and Emacs. Metals is developed at the Scala Center and VirtusLab along with contributors from the community.

In this release we merged 11 PRs and closed 5 issues, full details: https://github.com/scalameta/metals/milestone/18?closed=1

TL;DR

Check out the website and give Metals a try: https://scalameta.org/metals/

  • add support for Scala 2.12.10 and 2.13.1
  • formatting on paste for multiline strings
  • fixes for autofill feature

Add support for Scala 2.12.10 and 2.13.1

Thanks to @gabro's continuing effort we were able to add support for both new Scala versions. Those versions fix a couple of important regressions and are now available to use with Metals!

Formatting on paste for multiline strings

Whenever text is pasted into a multiline string with | it will be properly formatted by Metals:

format-on-paste

To enable this feature you need to enable formatting on paste in your editor of choice. In Visual Studio Code it can be done via modifying a checkbox:

format-on-paste

Fixes for autofill feature

After releasing the experimental autofill feature we addressed feedback by:

  • not filling in the default arguments
  • adding ??? as a first option when alternative values are available to avoid mistakes
  • add subtypes as valid values
  • only show autofill option when using named parameters or by explicitly typing autofill...

Let us know if you have any further feedback!

Contributors

Big thanks to everybody who contributed to this release!

$ git shortlog -sn --no-merges v0.7.5..v0.7.6
Tomasz Godzik
Marek Żarnowski
Gabriele Petronella
Ólafur Páll Geirsson
Sam Halliday

Merged PRs

v0.7.6 (2019-09-23)

Full Changelog

Merged pull requests:

  • replace java streams with generators #938 (marek1840)
  • ENSIME is not an alternative #936 (fommil)
  • Swap field to type parameter for scala Type #933 (tgodzik)
  • Refactor autofill option #932 (tgodzik)
  • Make sure we continue searching for symbols in try. #930 (tgodzik)
  • Disable flaky test. #918 (olafurpg)
  • Fix indentation when adding pipes in multiline string. #922 (tgodzik)
  • Remove dealias to properly support type #921 (tgodzik)
  • Simplify testing when calculating position and automatically add pipes when copy pasting input #919 (tgodzik)
  • Add Scala 2.12.10 support and use 2.12.10 on Metals #913 (gabro)
  • Update isCompiled status of the build target regardless of the compilation result #907 (marek1840)

Metals v0.7.5 - Thorium

September 12, 2019

Tomasz Godzik

Tomasz Godzik

We are excited to announce the release of Metals v0.7.5 - codename "Thorium" 🎉 The release includes couple of bug fixes for 0.7.2, which were present in some rare scenarios. We also added a new experimental feature, which we would be happy to get feedback about.

Metals is a language server for Scala that works with VS Code, Atom, Vim, Sublime Text and Emacs. Metals is developed at the Scala Center and VirtusLab along with contributors from the community.

In this release we merged 12 PRs and closed 6 issues, full details: https://github.com/scalameta/metals/milestone/17?closed=1

TL;DR

Check out the website and give Metals a try: https://scalameta.org/metals/

  • add auto-fill option to case classes
  • deduce values for named parameters completions
  • multiple fixes after adding support for Scala 2.12.9
  • fixes for automatic addition of | in multiline strings

Add auto-fill option to case classes

Whenever we invoke a method and try completions inside the brackets there is an additional option to allow Metals to deduce what should be filled for each parameter.

auto-fill

This algorithm checks if there exists a value in scope with the same type as the parameters' and then works according to the rules below:

1. If there is only one candidate, use it.
2. If there is more than one, give user an alternative to choose one of them.
3. Otherwise use use "???".

This feature also uses the snippets syntax to allow to quickly go over the auto-filled parameters and choose or replace the auto-filled values.

Deduce values for named parameters completions

Leveraging the work that went into the previous feature, we were also able to provide additional support for concrete values in named parameter completions.

deduce

We generate completion item for each value that fits the type of the parameter.

Multiple fixes after adding support for Scala 2.12.9

After updating Metals to work with Scala 2.12.9 it turned out that completions and hover didn't work correctly and due to the presentation compiler crashing in the following scenarios:

  • whenever an older version of SemanticDB plugin was used as was the case with Mill
  • when using Scala 2.12.8 without SemanticDB plugin

Both issues have now been fixed and additionally we updated the default Mill version to 0.5.1, which works correctly with Scala 2.12.9.

Fixes for automatic addition of | in multiline strings

We now make sure that stripMargin exists when adding | automatically in multiline strings. This could cause issues in some scenarios, where multiline string contained |, but it was not only used for formatting.

Additionally, we fixed the feature to also work in interpolated strings, which was missing in the previous release.

Contributors

Big thanks to everybody who contributed to this release!

$ git shortlog -sn --no-merges v0.7.2..v0.7.5
Tomasz Godzik
Gabriele Petronella
Łukasz Byczyński
Olafur Pall Geirsson

Merged PRs

v0.7.5 (2019-09-12)

Full Changelog

Merged pull requests:

Metals v0.7.2 - Thorium

September 2, 2019

Tomasz Godzik

Tomasz Godzik

We are excited to announce the release of Metals v0.7.2 - codename "Thorium" 🎉 The release includes mostly bug fixes with some smaller new features. We are skipping over 0.7.1 due to a critical bug we discovered

Metals is a language server for Scala that works with VS Code, Atom, Vim, Sublime Text and Emacs. Metals is developed at the Scala Center and VirtusLab along with contributors from the community.

In this release we merged 39 PRs and closed 11 issues, full details: https://github.com/scalameta/metals/milestone/14?closed=1

TL;DR

Check out the website and give Metals a try: https://scalameta.org/metals/

  • support for Scala 2.12.9
  • fix completions in case of inline comments
  • add support for non-directory sources
  • automatically add package definition to new source files
  • automatically insert pipes in multiline string
  • a lot of miscellaneous fixes

Fix completions in case of inline comments

Previously, completions after a comment and newline would yield no results:

val List(1,2,3)
  .map(num => num + 1) // comment
  @@

This was fixed by the Metals team in the presentation compiler itself for 2.12.9 and 2.13.1, however we also added a workaround for all supported older Scala versions.

Add support for non-directory sources

In case that your build tool supports having single files as sources, we now offer full support for them. That corresponds to the most recent BSP specification request

Automatically add package definition to new source files

For every new Scala file we automatically add package definition based on the relative path between the new source file and source root. This is done using applyWorkspaceEdit method, which causes the change to be done in editor and this can easily be rewerted like any other change you would type.

add-package

We also added support for package objects. Whenever you create package.scala file, we will automatically create the barebone definition of the package object.

package-object

There is still some work to be done about moving files between packages, which will be addressed in the next release.

Big thanks to the first time contributor from VirtusLab Tomasz Dudzik for implementing most of the functionality! 🎉

Automatically insert pipes in multiline string

We finally managed to properly support adding | in multiline strings using the onTypeFormatting method. Previous implementation was very naive and often added pipes in wrong places.

pipes

To enable the functionality you need to enable onTypeFormatting inside your editor if it's not enabled by default.

In Visual Studio Code this needs to be done in settings by checking Editor: Format On Type:

on-type

You will also need the newest version of the Visual Studio Code plugin.

There is still some possible improvements in case of copy pasting entire text fragments, but that needs some more work.

Big thanks to another of our first time contributors from VirtusLab Karolina Bogacka! Great work! 🎉

Add support for Scala 2.12.9

Metals now supports Scala 2.12.9! No new Scala version has been deprecated in this release, since it is possible that Scala 2.12.10 version with some important fixes will be released soon.

Big thanks to @gabro for again leading the effort! This took considerably more time and effort than expected.

Miscellaneous fixes

  • erroneous warning for Scala 2.11 is no longer displayed
  • don't infer build target for non-readonly files
  • fix several small issues in the tree view protocol spec
  • set h2.bindAddress to avoid exposing open ports (thanks @blast-hardcheese!)
  • resolve symlinks that are used within workspaces
  • fix issues when import was requested multiple times without any change
  • detect openjdk as a valid jdk home
  • warn when java sources were not found
  • string interpolation completions now work properly in multiline string
  • add ReloadDoctor to the list of all commands (thanks @kurnevsky!)
  • add correct mill version in the predef script when running bloopInstall
  • SemanticDB plugin issues are no longer reported in java only projects
  • check if SeamnticDB really exists and only report issue when it doesn't
  • update default scalafmt to 2.0.1
  • use recommended version for build tools in UI message
  • fix file leak when importing large Gradle workspaces

Contributors

Big thanks to everybody who contributed to this release, a lot more people joined this time to make the release better!

$ git shortlog -sn --no-merges v0.7.0..v0.7.2
Gabriele Petronella
Tomasz Godzik
Ólafur Páll Geirsson
Evgeny Kurnevsky
Marek Żarnowski
Lucas Satabin
Ayoub Benali
Chris Birchall
Compro Prasad
Devon Stewart
Jesús Martínez
Karolina Bogacka
Tomasz Dudzik
Chris Kipp
Rikito Taniguchi

Merged PRs

v0.7.2 (2019-08-29)

Full Changelog

Merged pull requests:

  • Fix not closing streams when using Files.list #892 (tgodzik)
  • Avoid file leaks when digesting Gradle builds #889 (olafurpg)
  • Fix broken tests #888 (olafurpg)
  • Bump Metals Scala version to 2.12.9 #887 (tgodzik)
  • Add check mark for formatting under vim #885 (satabin)
  • Recommend a recent version of the build tool when incompatible or unknown #881 (gabro)
  • Use BuildInfo.scalaCompilerVersion over Properties.versionNumberString #876 (olafurpg)
  • Remove use of early intializers #877 (gabro)
  • Catch ShutdownReq exception from stopping a presentation compiler. #873 (olafurpg)
  • Transpose features/editors table #875 (gabro)
  • Make presentation compiler work on 2.12.9 #872 (gabro)
  • Scala 2.12.9 support #867 (gabro)
  • Automatically add package objects when creating package.scala file #866 (tgodzik)
  • Automatically add package declaration when creating a file #862 (tdudzik)
  • Fix TreeViewSlowSuite tests #864 (gabro)
  • Update scalafmt to 2.0.1 #863 (tanishiking)
  • Add support for non-directory sources #857 (tgodzik)
  • Report an issue only if SemanticDB file doesn't really exist. #853 (tgodzik)
  • Do not report issues in Java only projects #850 (tgodzik)
  • Emacs supports client commands now #848 (kurnevsky)
  • Fix issue if exact query is longer than the class name #843 (tgodzik)
  • Fix issue with wrong mill version in predef script and update millw scripts #842 (tgodzik)
  • Fix Mercury blog post date by adding an unlisted redirect #836 (gabro)
  • Update sublime doc regarding autoimport #839 (ayoub-benali)
  • Improve handling of the java sources #825 (marek1840)
  • Add exact libraries that are expected and fix the test #837 (tgodzik)
  • Add ReloadDoctor to the list of all commands. #830 (kurnevsky)
  • Install use-package if not already installed #828 (Compro-Prasad)
  • Fix multiline edits #826 (tgodzik)
  • Timestamps should use currentTimeMillis #822 (tgodzik)
  • resolve symlinks from client requests #824 (marek1840)
  • Setting h2.bindAddress to avoid exposing open ports #821 (blast-hardcheese)
  • Use Scalafmt 2.0.0 when setting the version in .scalafmt.conf #806 (gabro)
  • Don't infer build target for non-readonly files. #810 (olafurpg)
  • Fix versions in docs - wrong number of @ was used #820 (tgodzik)
  • Update the list of supported Scala binary versions #818 (cb372)
  • Bump mill version #817 (satabin)
  • Send treeViewDidChange only when the client supports it #816 (kurnevsky)
  • Fix issue with missing completions after comment and newline. #814 (tgodzik)
  • Fix several issues in the tree view protocol spec #811 (olafurpg)
  • Make test-release.sh script check that artifacts have synced to Maven #812 (olafurpg)
  • nvim version and updated info about required java versions #807 (ckipp01)
  • Lost a word in the last PR and adding it now #805 (tgodzik)
  • Use sonatype:public in our own meta build #803 (gabro)
  • Fix an issue with wrong deprecation warning for 2.11 and update snapshot version #804 (tgodzik)
  • Fix version typo #802 (JesusMtnez)

Metals v0.7.0 - Thorium

June 28, 2019

Ólafur Páll Geirsson

Ólafur Páll Geirsson

We are excited to announce the release of Metals v0.7.0 - codename "Thorium" 🎉 The release includes several new features along with bug fixes.

Metals is a language server for Scala that works with VS Code, Atom, Vim, Sublime Text and Emacs. Metals is developed at the Scala Center and VirtusLab along with contributors from the community.

In this release we merged 21 PRs and closed 8 issues, full details: https://github.com/scalameta/metals/milestone/11?closed=1

TL;DR

  • New tree view in VS Code
  • New support for Scala 2.13
  • New support for JDK 11
  • New improved classpath indexing performance
  • New fallback to "find references" when calling "goto definition" on a symbol definition
  • Bug fixes for importing builds in Gradle, Mill and sbt
  • Dropped support for deprecated Scala versions 2.11.9, 2.11.10, 2.11.11, 2.12.4, 2.12.5 and 2.12.6.

Check out the website and give Metals a try: https://scalameta.org/metals/

Tree views in VS Code

There is now a new "Metals" sidebar in VS Code that contains three tree views:

  • Build: overview of the build state, with buttons to manually trigger build import.
  • Compile: overview of ongoing compilations, with buttons to manually cascade compilation and cancel ongoing compilation.
  • Help and feedback: buttons to automate troubleshooting Metals issues and links to relevant online resources such as GitHub, Gitter and Twitter.

Projects explorer

2019-06-26 20 28 14

Libraries explorer

Browse symbols that are defined in jars of library dependencies.

2019-06-26 20 28 51

Reveal active file in Metals side bar

There is a new command "Reveal active file in Metals side bar" that focuses the library and project explorer to the current open file.

2019-06-27 16 02 33

Compilation explorer

Get an overview of all compilations that are ongoing in the build. Previously, only a single compilation progress was reported through the status bar.

2019-06-23 15 41 07

Help and feedback explorer

Screenshot 2019-06-27 at 15 57 15

Support for Scala 2.13

Metals now supports Scala 2.13.0! Please upgrade to Scalafmt v2.0.0 in order to format 2.13-specific syntax such as underscore separators (1_000_000). Note that completions may in rare situations not work perfectly for Scala 2.13, in particular:

  • whitebox string interpolator macros, we had to disable one unit test for 2.13. See #777.
  • better-monadic-for compile plugin, we had to disable one unit test for 2.13. See #777.

Big thanks to @gabro for leading this effort!

JDK 11 support

Metals can now run on Java 11! To use Java 11 instead of Java 8, point the $JAVA_HOME environment variable to a Java 11 installation.

The VS Code extension will continue to use Java 8 by default, update the "Java Home" setting to use Java 11 instead.

To obtain the Java 11 home on macOS, use the following command:

$ /usr/libexec/java_home 11
/Library/Java/JavaVirtualMachines/openjdk-11.0.1.jdk/Contents/Home

Big thanks to @er1c for pushing for the effort on both the Bloop and Metals side to support Java 11!

Improved classpath indexing performance

Previously, to support fuzzy symbol search Metals indexed classpath elements using an algorithm that required a quadratic iteration on the number of characters in classfile names. Now, the fuzzy symbol search algorithm only requires a linear pass on the characters of a classfile name. This optimization resulted in a 2x speedup for indexing a 235Mb classpath in our benchmarks.

  Benchmark                   Mode  Cnt     Score    Error  Units
- ClasspathIndexingBench.run    ss   10  1809.068 ± 61.461  ms/op # JDK 8
+ ClasspathIndexingBench.run    ss   10  919.237  ± 42.827  ms/op # JDK 8
+ ClasspathIndexingBench.run    ss   10  1316.451 ± 22.595  ms/op # JDK 11

Fallback to "find references" from "goto definition"

Previously, nothing happened when invoking "goto definition" on the symbol definition itself. Now, Metals falls back to "find references" in this situation.

Fallback

Big thanks to @tanishiking for contributing this new feature!

Dropping older Scala versions

The Scala versions supported by Metals are now the following.

VersionOld StatusNew Status
2.11.9DeprecatedDropped
2.11.10DeprecatedDropped
2.11.11DeprecatedDropped
2.11.12SupportedDeprecated, with no plans to be dropped in upcoming releases*
2.12.4DeprecatedDropped
2.12.5DeprecatedDropped
2.12.6DeprecatedDropped
2.12.7SupportedDeprecated, please upgrade to 2.12.8
2.12.8SupportedSupported
2.13.0UnsupportedSupported

* Scala 2.11 support will likely stay around for a while given the situation with Spark, Scala Native, Playframework and other libraries and frameworks that have been late to adopt 2.12. Our download numbers show that ~10% of Metals users are still on 2.11. Nevertheless, we encourage our users to upgrade to 2.12 to enjoy a better code editing experience thanks to multiple improvements in the compiler.

Fixes for auto importing builds

  • digest only .sbt files at workspace level for sbt projects (thanks @wojciechUrbanski!)
  • fix SemanticDB plugin path on Windows for Gradle workspaces
  • update default Mill version to 0.4.1 to fix an issue with classpath not containing Scala library
  • Metals now pick up the version from .mill-version for the millw script

No more "work in progress"

Previously, the Metals website used the "Work-in-progress language server for Scala" tagline to reflect the experimental status of the project. Now, the tagline on the website has been changed to "Scala language server with rich IDE features" to reflect that Metals is used by thousands of developers today for their day-to-day coding.

Miscellaneous fixes

  • fix off-by-one for parameter hints when the cursor was after the closing ) parenthesis
  • make sure we add an autoimport in the correct line in case of brackets
  • document symbol outline no longer fails when val _ = () is the only thing in a block expression
  • nested objects are now imported correctly in case of deeper nesting
  • fix concurrent modification in text document cache (thanks @chikei!)

Contributors

Big thanks to everybody who contributed to this release, it's amazing we had a couple of new contributors to Metals!

$ git shortlog -sn --no-merges v0.6.1..v0.7.0
Gabriele Petronella
Ólafur Páll Geirsson
Tomasz Godzik
Eric Peters
tanishiking
Ruben Berenguel
TzeKei Lee
Wojciech Urbanski

Merged PRs

v0.7.0 (2019-06-28)

Full Changelog

Merged pull requests:

  • Upgrade to Scalameta v4.2.0 #799 (olafurpg)
  • Introduce Tree View Protocol #797 (olafurpg)
  • Add a benchmark for classpath indexing performance. #795 (olafurpg)
  • Migrate Java converters to 2.13 #794 (gabro)
  • Remove dot as a commit character #793 (tgodzik)
  • Make classpath indexing linear instead of quadratic. #792 (olafurpg)
  • Use 2.13 dialect for syntax errors #789 (gabro)
  • Fix off-by-one for parameter hints. #786 (olafurpg)
  • Make sure we add an autoimport in the correct line #785 (tgodzik)
  • Fix typo #784 (tanishiking)
  • Remove Work-in-progress from the tagline #782 (gabro)
  • Fix JdkSources not to ignore JAVA_HOME environment variable #781 (tanishiking)
  • Fix importing nested objects #778 (tgodzik)
  • Fix an issue when val \_ = \(\) is the only thing in the block #776 (tgodzik)
  • Fallback to "show usages" from "Goto definition" if the symbol represents a definition itself #775 (tanishiking)
  • Move slow tests to separate directories and run them separately on Travis #773 (tgodzik)
  • Digest only sbt files at workspace level #772 (wojciechUrbanski)
  • Fix wrong windows SemanticDB file path #771 (tgodzik)
  • Fix concurrent modification #766 (chikei)
  • Factor out a ClasspathLoader.getURLs(classLoader) helper for java9+ compatability, update usages #765 (er1c)
  • Include mill version from .mill-version file #764 (tgodzik)
  • Add 2.13 support and drop deprecated versions #763 (gabro)
  • Clarifiyng a setting #759 (rberenguel)
  • Fix very small typo in docs #758 (rberenguel)
  • Fix completions to compilation in blog #757 (tgodzik)
  • Update VS Code docs #756 (tgodzik)
  • Add release notes for Metals Radium release #752 (tgodzik)
Next →