Don't widen constants if that causes a loss of precision

Author: odersky

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -29,6 +29,7 @@ import config.Printers.{typr, unapp, overload}
 import TypeApplications._
 import language.implicitConversions
 import reporting.diagnostic.Message
+import Constants.{Constant, IntTag, LongTag}
 
 object Applications {
   import tpd._
@@ -1449,11 +1450,19 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         !(cls == defn.LongClass && sup.isRef(defn.FloatClass))
           // exclude Long <: Float from list of allowable widenings
           // TODO: should we do this everywhere we ask for isValueSubType?
+
       val lub = defn.ScalaNumericValueTypeList.find(lubTpe =>
         clss.forall(cls => isCompatible(cls, lubTpe))).get
+
+      def lossOfPrecision(ct: Constant): Boolean =
+        ct.tag == IntTag && lub.isRef(defn.FloatClass) &&
+          ct.intValue.toFloat.toInt != ct.intValue ||
+        ct.tag == LongTag && lub.isRef(defn.DoubleClass) &&
+          ct.longValue.toDouble.toLong != ct.longValue
+
       val ts1 = ts.mapConserve { t =>
         tpe(t).widenTermRefExpr match {
-          case ct: ConstantType => adapt(t, lub)
+          case ct: ConstantType if !lossOfPrecision(ct.value) => adapt(t, lub)
           case _ => t
         }
       }

docs/docs/reference/dropped/weak-conformance.md

@@ -40,7 +40,8 @@ assigning a type to a constant expression. The rule is:
    and all expressions have primitive numeric types, but they do not
    all have the same type, then the following is attempted: Every
    constant expression `E` in `Es` is widened to the least primitive
-   numeric value type above the types of all expressions in `Es`. Here
+   numeric value type equal to or above the types of all expressions in `Es`,
+   if that can be done without a loss of precision. Here
    _above_ and _least_ are interpreted according to the ordering given
    below.
 
@@ -55,24 +56,32 @@ assigning a type to a constant expression. The rule is:
                 |
               Byte
 
-    If these widenings lead to all expressions `Es` having the same type,
-    we use the transformed list of expressions instead of `Es`, otherwise
-    we use `Es` unchanged.
+    A loss of precision occurs for an `Int -> Float` conversion of a constant
+    `c` if `c.toFloat.toInt != c`. For a `Long -> Double` conversion it occurs
+    if `c.toDouble.toLong != c`.
+
+    If these widenings lead to all widened expressions having the same type,
+    we use the widened expressions instead of `Es`, otherwise we use `Es` unchanged.
 
 __Examples:__
 
-    inline val b: Byte = 3
-    inline val s: Short = 33
-    def f(): Int = b + s
-    List(b, s, 'a')     : List[Int]
-    List(b, s, 'a', f()): List[Int]
-    List(1.0f, 'a', 0)  : List[Float]
-    List(1.0f, 1L)      : List[Double]
-    List(1.0f, 1L, f()) : List[AnyVal]
-
-The expression on the last line has type `List[AnyVal]`, since widenings
-only affect constants. Hence, `1.0f` and `1L` are widened to `Double`,
-but `f()` still has type `Int`. The elements don't agree on a type after
-widening, hence the expressions are left unchanged.
+    inline val b = 33
+    def f(): Int = b + 1
+    List(b, 33, 'a')      : List[Int]
+    List(b, 33, 'a', f()) : List[Int]
+    List(1.0f, 'a', 0)    : List[Float]
+    List(1.0f, 1L)        : List[Double]
+    List(1.0f, 1L, f())   : List[AnyVal]
+    List(1.0f, 1234567890): List[AnyVal]
+
+The expression on the second-to-last line has type `List[AnyVal]`,
+since widenings only affect constants. Hence, `1.0f` and `1L` are
+widened to `Double`, but `f()` still has type `Int`. The elements
+don't agree on a type after widening, hence the elements are left
+unchanged.
+
+The expression on the last line has type `List[AnyVal]` because
+`1234567890` cannot be converted to a `Float` without a loss of
+precision.
 
 

tests/pos/harmonize.scala

@@ -38,6 +38,21 @@ object Test {
 
     val xs = List(1.0, nn, 'c')
     val ys: List[Double] = xs
+
   }
 
+  inline val b = 33
+  def f(): Int = b + 1
+  val a1 = Array(b, 33, 'a')
+  val b1: Array[Int] = a1
+  val a2 = Array(b, 33, 'a', f())
+  val b2: Array[Int] = a2
+  val a3 = Array(1.0f, 'a', 0)
+  val b3: Array[Float] = a3
+  val a4 = Array(1.0f, 1L)
+  val b4: Array[Double] = a4
+  val a5 = Array(1.0f, 1L, f())
+  val b5: Array[AnyVal] = a5
+  val a6 = Array(1.0f, 1234567890)
+  val b6: Array[AnyVal] = a6
 }