Dropped: Weak Conformance  More Details
To simplify the underlying type theory, Scala 3 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 ifthenelse 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 intoInt
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 ofByte
,Short
,Char
,Int
,Long
,Float
,Double
), possibly after widening, and if none of theInt
literals would incur a loss of precision when converted toT
, 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 constantc
ifc.toFloat.toInt != c
 an
Int > Byte
conversion of a constantc
ifc.toByte.toInt != c
,  an
Int > Short
conversion of a constantc
ifc.toShort.toInt != c
.
 the expressions
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]
In this article