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.
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.
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.
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 ???.
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.
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!
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.
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.
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.
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.
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.
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.
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:
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:
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. Additionally, we implemented experimental support for the Pants build
tool.
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.
Pants, 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.
Experimental build tool support for Pants
Thanks to the recent work by @olafurpg, there's
now experimental support for the Pants build tool. The Pants integration is
still evolving so it's not yet documented. The end goal is to support Pants in
the same way as other build tools like sbt, Maven and Gradle.
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.
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.
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)
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.
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.
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:
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:
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
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.
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.
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.
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!
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.
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:
valList(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.
We also added support for package objects. Whenever you create package.scala
file, we will automatically create the barebone definition of the 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.
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:
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!
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.
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
Libraries explorer
Browse symbols that are defined in jars of library dependencies.
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.
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.
Help and feedback explorer
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 @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.
Big thanks to @tanishiking for contributing
this new feature!
Dropping older Scala versions
The Scala versions supported by Metals are now the following.
Version
Old Status
New Status
2.11.9
Deprecated
Dropped
2.11.10
Deprecated
Dropped
2.11.11
Deprecated
Dropped
2.11.12
Supported
Deprecated, with no plans to be dropped in upcoming releases*
2.12.4
Deprecated
Dropped
2.12.5
Deprecated
Dropped
2.12.6
Deprecated
Dropped
2.12.7
Supported
Deprecated, please upgrade to 2.12.8
2.12.8
Supported
Supported
2.13.0
Unsupported
Supported
* 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!
We are excited to announce the release of Metals v0.6.1, codename "Radium" 🎉
The release mostly focused on adding support for the build tools Gradle, Maven
and Mill.
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 along with contributors from the
community.
Metals now depends on Bloop v1.3.2 instead of v1.2.5. The v1.3 release of Bloop
has a ton of nice improvements that benefit Metals users. For full details, see
the
Bloop v1.3.0 release notes.
Automatic "import build" for Gradle, Maven and Mill
Now, it's possible to use Metals with the build tools Gradle, Maven and Mill!
Importing a build with Gradle, Maven and Mill now works the same way it works
for sbt.
For more details, see the corresponding documentation for each build tool:
An issue where the Metals process could continue running even after closing the
editor has now been fixed.
Completions freeze less
An issue where Metals could get stuck in an infinite loop using 100% CPU while
responding to completions has now been fixed.
Keyword completions
Previously, Metals did not complete keywords like import, new, lazy val or
trait. Language keywords are now included in the auto-completions in most
cases.
objectMain{
// Before
impo<COMPLETE>
// Afterimport
}
Keywords are suggested based on the context (e.g. you won't see throw suggested
if the cursor is not inside a declaration)
The only keywords that are not completed are: extends, finally, with,
forSome, catch and finally.
VS Code doesn't compile projects until it is focused
Previously, Metals would trigger compilation in the background even if the VS
Code window was not focused. For example, switching git branches in a separate
terminal window would still trigger compilation in Metals. Now, Metals waits
until the VS Code window is focused to trigger compilation.
This feature is implemented as a LSP extension and is currently only supported
by VS Code. For details on how to implement this extension for another editor,
see the
documentation on integrating a new text editor.
Metals is now a default server in the Sublime LSP package
Metals is now a default server for Scala source files in the LSP package, see
tomv564/LSP#571. This greatly
simplifies the installation steps for Sublime Text users.
Contributors
Big thanks to everybody who contributed to this release!
This release introduces minor improvements and bug fixes with highlights
including:
auto-imports are inserted at the toplevel instead of locally
document symbol lists inner methods and anonymous classes
the recommended Vim client is now coc.nvim
diagnostics are cleared for deleted files
fuzzy symbol search no longer returns results for deleted files
find all references now handles synthetic update calls
deprecate older Scala versions
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 along with contributors from the
community.
Now, the import is inserted at the toplevel instead
import scala.concurrent.Future// <- automatically added by MetalsobjectMain{
val future = Future@@
}
Document symbols now shows inner methods and anonymous classes
Before:
After:
Diagnostics gracefully handle deleted files
Previously, deleting a file with compile errors would result in the stale
diagnostics to stay until you restarted the Metals server. Now, diagnostics are
cleared when a source file is deleted.
Fuzzy symbol search gracefully handles deleted files
Previously, fuzzy searching for a symbol could return results from deleted
files. Now, fuzzy symbol search only shows results from files that exist on
disk.
Find all references handles synthetic update calls
Previously, find all references did not catch references where an update()
method call was synthesized.
val cache = mutable.Map.empty[String, String]
cache("a") = "b"// before: referenced `Map.update()` instead of `cache`
Now, the reference to cache in cache("a") = "b" is indexed as well as the
synthetic call to the Map.update() method.
The recommended Vim client is now coc.nvim
Previously, the
vim installation instructions
recommended the vim-lsc client. Now, the installation instructions recommend
coc.vim since it supports more functionality of the Language Server Protocol. If
you use Vim, we recommend trying out coc.vim to enjoy more advanced features
like completions with auto-imports.
Deprecate older Scala versions
Metals works with Scala 2.11 and Scala 2.12. Starting from the next release,
Metals will drop support for the older patch versions of those series, and it
will exclusively support these version:
2.11.12
2.12.7
2.12.8
Starting from this release, we will show a warning at startup if you're using an
outdated Scala version, prompting you to upgrade your project to the latest
version.
Contributors
Big thanks to everybody who contributed to this release!
We are excited to announce the release of Metals v0.5, codename "Mercury" 🎉
This release introduces new features, performance improvements and bug fixes
with highlights including:
code completions
parameter hints
show type at point
code folding
document highlight
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 along with contributors from the
community.
It's now possible to use code completions to explore APIs, implement interfaces,
generate exhaustive pattern matches and more.
Auto-import: symbols that are not in scope are automatically imported
locally. Imports still need to be organized manually, we are exploring ways to
automate this workflow in the future.
Override def: implement methods from the super class.
Exhaustive match: generate an exhaustive pattern match for sealed types.
String interpolator: automatically convert string literals into string
interpolators.
Filename: complete classnames based on the enclosing file.
Documentation: read the docstring for method symbols by pressing
ctrl+space in VS Code.
Hover (aka. type at point)
It's now possible to see the expression type and symbol signature under the
cursor.
Expression type: shows the non-generic type of the highlighted expression.
Symbol signature: shows the generic signature of symbol under the cursor
along with its docstring, if available.
Signature help (aka. parameter hints)
It's now possible to view a method signature and overloads as you fill in
arguments.
Code folding
It's now possible to fold ranges such as large expressions, import groups and
comments.
Big thanks to @marek1840 for contributing this
feature!
Document highlight
It's now possible to highlight references to the same symbol in the open file.
Big thanks to @tgodzik for contributing this
feature!
Faster and more relevant fuzzy symbol search
Previously, fuzzy symbol search (workspace/symbol in LSP) always returned
results from both the workspace and library dependencies. Now, fuzzy symbol
search returns only results from the workspace unless the query contains a
semicolon character ;. For example:
query "Future": workspace only, with fallback to library dependencies if
workspace contains 0 results
queries "Future;" or ";Future" or "Fut;ure": workspace + library dependencies.
This change improves the quality for the search results since most often you
want to navigate to symbols defined in the workspace. A nice side-effect is that
workspace-only searches are faster because we avoid redundant work by not
looking at library dependencies.
In addition, this release introduces a new in-memory index for workspace-only
symbol queries resulting in even better performance compared to the last
release.
Goto definition for in-memory edits
Previously, goto definition worked only for identifiers that had been saved and
successfully compiled in the build tool. Now, you can use goto definition for
symbols that you just typed even if the source file hasn't been saved or
contains type errors.
Standalone Scala files outside a build tool
Previously, semantic features like goto definition worked only for sources that
belong to a build project. Now, Metals provides completions, parameter hints,
hover and definition for local symbols in standalone Scala files. The classpath
for standalone Scala files includes the JDK and the Scala standard library so
features like completion will not understand symbols from external library
dependencies.
Known limitation: only syntax errors are published for standalone Scala
files, the file must belong to a build in order to see type errors.
New collaboration with VirtusLab
As part of a new collaboration between VirtusLab and
the Scala Center, Marek Żarnowski (@marek1840)
and Tomasz Godzik (@tgodzik) will be contributing
to Metals development for the coming months. They have already contributed
several impressive pull requests:
textDocument/foldingRange(#632): code folding that
understands Scala syntax.
textDocument/documentHighlight(#621): highlight occurrences
of a symbol in the current file.
textDocument/completion(#640): override def
completions from without the need to type "override def ".
It is our pleasure to welcome them to the team and we look forward to working
together with them to improve the Scala editing experience :)
Contributors
Big thanks to everybody who contributed to this release! In particular, big
thanks to @jvican and
@gabro for invaluable feedback both online and
offline.
