[JVM] Use StableValue as compilation target for lazy val

Compiler
1

JEP 502 introduces the StableValue api (previously known as ComputableConstant). The api can be used to create constants with delayed (at-most-once) initialisation. The unique selling point of this api is that the JIT will trust the values for constant folding.
At a glance, this api seems like the perfect compilation target for Scala’s lazy vals. I can imagine two benefits over the current compilation strategy:

  1. Simpler generated code; the whole ‘checking whether a lazy value is already initialised’ logic is delegated to the StableValue api.
  2. Lazy immutable data structures may see some performance improvements in hot paths.

Having said that; the StableValue api is still in preview, and officially it doesn’t even target JDK 25 yet. Is there a precedent of the Scala compiler using preview apis, or is this out of the question (even for performance benchmarks)?

1 Like
2

I’m afraid it’s basically out of the question. We can’t even use stable features of recent JDKs, as we have to support older JDKs.

It may be interesting to evaluate what performance we could, theoretically, gain. It’s possible for someone to alter the codegen in a branch, and do some measurements with that. However, it is very unlikely that we will merge such a branch, because it will be effectively dead code for the next 5 to 10 years.

2 Likes
3

We could consider emitting bytecode that requires a specific minimal JDK version conditional on the value of the -release flag.

8 Likes
4

There are also other candidates for targeting newer JVM bytecode

  • record for case classes
  • sealed
  • and maybe some other things
5

There should be other forum threads about these topics. I’d like to keep this thread on the topic of stable values / lazy vals.

3 Likes
6

This would be ideal IMO – I think Kotlin does exactly that: FAQ | Kotlin Documentation