Primitive operations on Long with Float argument have different semantics from Java

[densh]

Scala's primitive binary operations on Long that take Float (e.g. (x: Long) % (y: Float)) as an argument erroneously perform an operation in double precision, instead of float precision. This is inconsistent wrt Java semantics.

Java code:

public class JavaTest {
    private static float a() {
        return java.lang.Float.intBitsToFloat(1079290514);
    }

    private static long b() {
        return 1412906027847L;
    }

    public static void main(String[] args) {
        float r1 = b() % a();
        System.out.println(r1);
        float r2 = (float) ((float) b()) % ((float) a());
        System.out.println(r2);
        float r3 = (float) ((double) b()) % ((double) a());
        System.out.println(r3);
    }
}

Java output:

# java JavaTest
1.164309
1.164309
2.3242621

Scala code:

object Test {
  def a(): Float =
    java.lang.Float.intBitsToFloat(1079290514)
  def b(): Long =
    1412906027847L
  def main(args: Array[String]): Unit = {
    val r1: Float = b() % a()
    println(r1)
    val r2: Float = (b().toFloat % a().toFloat).toFloat
    println(r2)
    val r3: Float = (b().toDouble % a().toDouble).toFloat
    println(r3)
  }
}

Scala output:

# scala Test
2.3242621
1.164309
2.3242621

Found by random test generation for Scala Native (http://github.com/densh/testgen).

[densh]

Scala Native and Scala.js (according to @sjrd) have the expected semantics like Java but it differs from Scala on the JVM.

[sjrd]

The code to be blamed is at https://github.com/scala/scala/blob/051e7b61cb18b7ed9593f38a4bc73b69e8199775/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala#L311-L314. It should have an additional case for other == FLOAT in which case the result should be FLOAT. Note how the case right below for case FLOAT => will correctly return FLOAT when other == LONG. So right now maxValueType is not commutative 😱