Dropped: Weak Conformance - More Details

To simplify the underlying type theory, Dotty drops the notion of weak conformance altogether. Instead, it provides more flexibility when assigning a type to a constant expression. The new rule is:

• If a list of expressions Es appears as one of

  • the elements of a vararg parameter, or
  • the alternatives of an if-then-else or match expression, or
  • the body and catch results of a try expression,

  and all expressions have primitive numeric types, but they do not all have the same type, then the following is attempted:

  • the expressions Es are partitioned into Int constants on the one hand, and all other expressions on the other hand,
  • if all the other expressions have the same numeric type T (which can be one of Byte, Short, Char, Int, Long, Float, Double), possibly after widening, and if none of the Int literals would incur a loss of precision when converted to T, then they are thus converted (the other expressions are left unchanged regardless),
  • otherwise, the expressions Es are used unchanged.

  A loss of precision occurs for an Int -> Float conversion of a constant c if c.toFloat.toInt != c. For an Int -> Byte conversion it occurs if c.toByte.toInt != c. For an Int -> Short conversion, it occurs if c.toShort.toInt != c.

Examples

inline val b = 33
def f(): Int = b + 1
Array(b, 33, 5.5)      : Array[Double] // b is an inline val
Array(f(), 33, 5.5)    : Array[AnyVal] // f() is not a constant
Array(5, 11L)          : Array[Long]
Array(5, 11L, 5.5)     : Array[AnyVal] // Long and Double found
Array(1.0f, 2)         : Array[Float]
Array(1.0f, 1234567890): Array[AnyVal] // loss of precision
Array(b, 33, 'a')      : Array[Char]
Array(5.toByte, 11)    : Array[Byte]