Refine the type of inline vals with literal rhs

[mbovel]

Closes #24321.

This PR changes the type of inline vals to be the exact type of the right-hand side if it is a literal, such that in following snippet, x would have type (4: Int):

inline val x: Int = 4

> scalac -Xprint:typer test.scala
...
[[syntax trees at end of                     typer]] // test.scala
...
    inline val x: (4 : Int) = 4
...

Previously, it would not compile:

$ scala -S 3.7.3 test.scala
Compiling project (Scala 3.7.3, JVM (17))
[error] ./test.scala:1:15
[error] inline value must have a literal constant type
[error] inline val x: Int = 4
[error]               ^^^
Error compiling project (Scala 3.7.3, JVM (17))
Compilation failed

[mbovel]

@sjrd do you think that would require a SIP?

[hamzaremmal]

@sjrd do you think that would require a SIP?

At least a minor release.

[sjrd]

It definitely needs a minor release.

In theory this is SIP material ... but IMO the SIP process is way too heavy for this. Let's add it to the next agenda, and hopefully there will be quick consensus.

[hamzaremmal]

Couldn't we have just reused the tracked system?

Nevermind, but I think it's worth checking the interactions between the two.

[mbovel]

I think it's worth checking the interactions between the two.

I added a test that checks that: https://github.com/dotty-staging/dotty/blob/345fcba592e8e9e276fc0cbcd4396682cb8739e7/tests/neg/inline-tracked-val.scala ✅

[odersky]

Not sure we have tests for these:

1. What happens for inline val x = 100: Byte? This should be equivalent to inline val x: Byte = 100.
2. What happens for inline val x: Byte = 1000? This should be a static error

[sjrd]

Possible alternative: add the toX methods to the set of constant-foldable methods. This is equally (in)compatible, but has a smaller footprint on our overall spec. We can keep the general rule that an explicit type is a real boundary (from an elaboration perspective).

inline val x = 4.toByte

would thus be Byte(4).

[odersky]

The problem is that 1000.toByte would give -24 instead of a static error

[mbovel]

1. What happens for inline val x = 100: Byte? This should be equivalent to inline val x: Byte = 100.

There is a test in inline-val.scala with Int, which currently expects a failure:

inline val a = 1 : Int // error

Should it pass? I guess it comes back to how powerful the constant-folding of the right-hand side should be. In #24431, I improved constant-folding for inline vals that are inside inline defs to go through ascriptions. We could use the same mechanism to type the right-hand side of inline vals that are not in inline defs as well. But that seems like a separate issue to me.

Note: this mechanism works on typed trees only, and we would need to adapt the untyped version for when there is an explicit ascription (#24321 (comment)), such as in:

inline val a: Int = 1 : Int

2. What happens for inline val x: Byte = 1000? This should be a static error

It is, I added a test.

[sjrd]

Half of the time I want wrapping to be able to write 0xff as a Byte. Moreover, there is precedent with the other constant foldable operations: 2000000000 + 2000000000 folds without error as well.

[mbovel]

Note from core meeting of 26.11.2025:

The change should go through a SIP process, since there is no consensus in the Core team.