Wrong manipulation of byte constants

[hamzaremmal]

Compiler version

3.7.3

Minimized code

class Foo {
    public static final byte MAX = 10;
}

object Bar:
  final val MAX: Byte = 10

val x = Foo.MAX to Foo.MAX
val y = Bar.MAX to Bar.MAX

Output

-- [E008] Not Found Error: test.scala:5:16 -------------------------------------
5 |val y = Bar.MAX to Bar.MAX
  |        ^^^^^^^^^^
  |        value to is not a member of Byte.
  |        An extension method was tried, but could not be fully constructed:
  |
  |            intWrapper(Bar.MAX)

Expectation

Both should fail because there is no to method available for Byte. The first one works because it gets converted to an Int.

package <empty> {
  final lazy module val Bar: Bar = new Bar()
  final module class Bar() extends Object() { this: Bar.type =>
    final val MAX: Byte = 10
  }
  final lazy module val test$package: test$package = new test$package()
  final module class test$package() extends Object() {
    this: test$package.type =>
    val x: scala.collection.immutable.Range.Inclusive = intWrapper(10).to(10)
    val y:
      
        <error value to is not a member of Byte.
An extension method was tried, but could not be fully constructed:

    intWrapper(Bar.MAX)>
        
     = Bar.MAX.to(Bar.MAX)
  }
}

[sjrd]

The same applies to Short constants (also from Java only), and also to Char constants (which can be written in Scala).

I wouldn't be surprised if it would also apply to Float constants where a Double is required.

[som-snytt]

The Scala 2 ticket was first reported for Scala 3
scala/bug#12473
but now

scala> ('a' to 'z').reverse
[[syntax trees at end of                     typer]] // rs$line$2
package <empty> {
  final lazy module val rs$line$2: rs$line$2 = new rs$line$2()
  final module class rs$line$2() extends Object() { this: rs$line$2.type =>
    val res0: scala.collection.immutable.NumericRange[Char] =
      charWrapper('a').to('z').reverse
  }
}

java.lang.ArithmeticException: number type is unsigned, and .reverse requires a negative step
  at scala.collection.immutable.NumericRange.reverse(NumericRange.scala:263)
  ... 30 elided

I see the expectation approves the lack of to.

[mbovel]

Here is the difference between Java and Scala:

• In Java, the constant MAX gets type (10 : Byte), which can then be adapted to a (10 : Int).
• In Scala, the constant just gets type Byte.

[mbovel]

Conclusions from compiler meeting:

• For the given snippet, the behavior is expected. It would make sense to give a more precise type to final vals, but we can't because of backward compatibility.
• However, we should be able to write inline val MAX: Byte = 10 and get it typed as (10 : Byte) (a constant type with value 10 and tag Byte).

[mbovel]

Also, we won't merge #23872 for 3.8. So this issue (or whatever issue will replace it) is not a blocker.