Scala 2.12.0-M5 is now available!

We are happy to announce the availability of Scala 2.12.0-M5!

Notable changes in M5 (see here for a more extensive list):

  • #5251: concrete trait methods are compiled to a static method (in the interface classfile) containing the actual implementation, and a default method forwards that to the static one.
  • #5085: classes extending traits no longer get mixin forwarders (in most cases), the JVM picks the correct default method.
  • #5102 adds partial unification of type constructors (behind -Ypartial-unification) and fixes SI-2712. Thanks @milessabin!
  • The optimizer now listens to -opt (instead of -Yopt)
  • SI-9390: local methods that don’t capture this are emitted as static to prevent capturing the outer instance in lambdas.

Note: #5085 introduces a performance regression, it causes the Scala compiler to run 20% slower. Any Scala program that uses concrete trait methods might see a slowdown. The most likely cause is that the JVM does not perform “class hierarchy analysis” (CHA) for methods defined in interfaces, including default methods, as noted in JDK bug 8036580. This prevents the JIT from performing certain (important) optimizations. Most likely we will have to revert the change to fix the issue, but we are still investigating the details. The 2.12 release notes will clarify the impact of changes to traits on binary compatibility.

In total, we merged 96 pull requests, of which 9 are by new contributors – welcome! This milestone resolves 49 JIRA tickets.

As usual for milestones, 2.12.0-M5 is not binary compatible with any other Scala release, including other 2.12 milestones. Scala 2.12 requires a Java 8 runtime.

Scala 2.12

Scala 2.12 is all about making optimal use of Java 8’s new features. Traits (#5003) and functions are compiled to their Java 8 equivalents, and we treat Single Abstract Method types and Scala’s builtin function types uniformly from type checking to the back end (#4971). We also use invokedynamic for a more natural encoding of other language features (#4896). We’ve standardized on the GenBCode back end (#4814, #4838) and the flat classpath implementation is now the default (#5057). The optimizer has been completely overhauled for 2.12.

Except for the breaking changes listed below, code that compiles on 2.11.x without deprecation warnings should compile on 2.12.x too, unless you use experimental APIs such as reflection. If you find incompatibilities, please file an issue.

New features

Since M4, we consider 2.12.x feature complete. For RC1, we will try to remain binary compatible with M5, and we won’t risk regressions except for the most critical bugs.

Trait compiles to an interface

With Java 8 allowing concrete methods in interfaces, Scala 2.12 is able to compile a trait to a single interface. Before, a trait was represented as a class that held the method implementations and an interface. Note that the compiler still has quite a bit of magic to perform behind the scenes, so that care must be taken if a trait is meant to be implemented in Java. (Briefly, if a trait does any of the following its subclasses require synthetic code: defining fields, calling super, initializer statements in the body, extending a class, relying on linearization to find implementations in the right super trait.)

Java 8-style lambdas

Scala 2.12 emits closures in the same style as Java 8, whether they target a FunctionN class from the standard library or a user-defined Single Abstract Method type. The type checker accepts a function literal as a valid expression for either kind of “function-like” type (built-in or SAM). This improves the experience of using libraries written for Java 8 in Scala.

For each lambda the compiler generates a method containing the lambda body, and emits an invokedynamic that will spin up a lightweight class for this closure using the JDK’s LambdaMetaFactory.

Compared to Scala 2.11, the new scheme has the advantage that, in most cases, the compiler does not need to generate an anonymous class for each closure. This leads to significantly smaller JAR files.

New back end

Scala 2.12 standardizes on the “GenBCode” back end, which emits code more quickly because it directly generates ASM bytecode from Scala compiler trees, while the previous back end used an intermediate representation called “ICode”. The old back ends (GenASM and GenIcode) have been removed (#4814, #4838).

New bytecode optimizer

The GenBCode back end includes a new inliner and bytecode optimizer. The optimizer is enabled using the -opt:l:classpath compiler option. Check -opt:help to see the full list of available options for the optimizer.

The following optimizations are available:

  • Inlining final methods, including methods defined in objects and final methods defined in traits
  • If a closure is allocated and invoked within the same method, the closure invocation is replaced by an invocations of the corresponding lambda body method
  • Dead code elimination and a small number of cleanup optimizations
  • Box/unbox elimination #4858

The work on the new optimizer is still ongoing. You can track it in the scala-dev repository issue tracker.

Breaking changes

SAM types

As of #4971, we treat Single Abstract Method types in the same way as our built-in FunctionN classes. This means overloading resolution has more contenders to choose from, making type inference less effective. Here’s an example:

class C[V] {
  def sort(cmp: java.util.Comparator[V]): C[V] = ???
  def sort(cmp: (V, V) => Int): C[V] = sort(
    new java.util.Comparator[V] {
      def compare(a: V, b: V): Int = cmp(a, b)
    })
}

(new C[Int]) sort (_ - _) // error
(new C[Int]) sort ((_ - _): java.util.Comparator[Int]) // ok
(new C[Int]) sort ((a: Int, b: Int) => a - b)  // ok

The first attempt fails because the type checker cannot infer the types for _ - _’s arguments anymore. Type inference in this scenario only works when we can narrow the overloads down to one before type checking the arguments the methods are applied to. When a function is passed as an argument to an overloaded method, we do this by considering the “shape” of the function (essentially, its arity). Now that Comparator[?] and (?, ?) => ? are both considered functions of arity two, our clever scheme breaks down and the programmer must either select an overload (second application) or make the argument types explicit (last application, which resolves to the Function2 overload).

Finally, implicit conversion of SAM types to Function types won’t kick in anymore, since the compiler does this conversion itself first:

trait MySam { def apply(x: Int): String }

implicit def unused(fun: Int => String): MySam
  = new MySam { def apply(x: Int) = fun(x) }

// uses sam conversion, not the `unused` implicit
val sammy: MySam = _.toString

Changed syntax trees (affects macro and compiler plugin authors)

PR #4794 changed the syntax trees for selections of statically accessible symbols. For example, a selection of Predef no longer has the shape q"scala.this.Predef" but simply q"scala.Predef". Macros and compiler plugins matching on the old tree shape need to be adjusted.

Binary compatibility

Since Scala 2.11, minor releases of Scala are binary compatible with each other. Scala 2.12 will continue this tradition: every 2.12.x release will be binary compatible with 2.12.0. Milestone releases and release candidates, however, are not binary compatible with any other release.

Scala 2.12 is not and will not be binary compatible with the 2.11.x series. This allows us to keep improving the Scala compiler and standard library. We are working with the community to ensure that core projects in the Scala eco-system become available for 2.12. Please refer to this growing list of libraries and frameworks.

The Scala 2.11.1 release notes explain in more detail on how binary compatibility works in Scala. The same policies apply to 2.12 as well.

Contributors

A big thank you to everyone who’s helped improve Scala by reporting bugs, improving our documentation, spreading kindness in mailing lists and other public fora, and submitting and reviewing pull requests! You are all magnificent.

According to git shortlog -sn --no-merges v2.12.0-M4..v2.12.0-M5, the following contributors helped to realize this milestone: Lukas Rytz, A. P. Marki, Jason Zaugg, Sébastien Doeraene, Adriaan Moors, Performant Data LLC, Simon Ochsenreither, Janek Bogucki, Miles Sabin, Felix Mulder, Stefan Zeiger, Rui Gonçalves, Raphael Jolly, Arno den Hartog, Viktor Klang, Olli Helenius, Kenji Yoshida, Steve Robinson, Taras Boiko, af, chrisokasaki, peterz, sh0hei, Łukasz Gieroń, Antoine Gourlay, Ben Hutchison, CodingTwinky, Dale Wijnand, Iulian Dragos, Jakob Odersky, Jens, Krzysztof Romanowski, Martijn Hoekstra, Mike Pheasant, Nafer Sanabria, Nicolas Stucki, Performant Data, Ruslan Sennov, Seth Tisue, Shixiong Zhu. Thank you!

Release notes

Improvements to these release notes are welcome!

Obtaining Scala