Unnecessary boxing when calling > on complex int type

[scf37]

Compiler version

3.1.2

Minimized code

import scala.compiletime.constValue

object Main {
  object types:
    type Validated[A] = A
    opaque type Max[A, max] <: A with Validated[A] = A
  import types.*

  trait Reader[A]:
    def read: A

  given Reader[Int] with
    def read: Int = 1

  inline given [max <: Int, V <: Int|Validated[Int], R <: Reader[V]](using r: R): Reader[Max[V, max]] = new Reader:
    def read: Max[V, max] =
      val v = r.read
      val limit = constValue[max]
      if (v > limit) v.asInstanceOf[Max[V, max]] else limit.asInstanceOf[Max[V, max]]

  val y = summon[Reader[Max[Int, 42]]]
}

Output

        y = new Main.Reader<Object>(){

            public int read() {
                int v = Main.given_Reader_Int$.MODULE$.read();
                int limit = 42;
                return new scala.runtime.RichInt(scala.Predef$.MODULE$.intWrapper(v)).$greater((Object)scala.runtime.BoxesRunTime.boxToInteger((int)42)) ? v : 42;
            }
        };

Expectation

        y = new Main.Reader<Object>(){

            public int read() {
                int v = Main.given_Reader_Int$.MODULE$.read();
                int limit = 42;
                return v > 42 ? v : 42;
            }
        };

[nicolasstucki]

Minimization

type Validated[A] = A
def foo(v: Int|Validated[Int]): Unit = v > 43

Problem

Even though the type of v is upper-bounded by Int we use the intWrapper for the > operation. Resulting with the following program after typing

type Validated[A >: Nothing <: Any] = A
def foo(v: Int | Validated[Int]): Unit = {
  intWrapper(v).>(43)
  ()
}

This is the source of the boxing as the operation will erase into RichInt.

Note that Int | Validated[Int] is correctly erased to Int.

[nicolasstucki]

Workaround

-      val v = r.read
+      val v: Int = r.read