Add reference section

Also, adapt the algorithm to the reference (i.e. convert
only if the resulting types all agree).

Author: odersky

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

@@ -445,7 +445,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 val harmonizedArgs = harmonizeArgs(typedArgs)
                 if (harmonizedArgs ne typedArgs) {
                   ctx.typerState.constraint = origConstraint
-                    // reset constraint, we will test constraint anyway when we
+                    // reset constraint, we will re-establish constraint anyway when we
                     // compare against the seqliteral. The reset is needed
                     // otherwise pos/harmonize.scala would fail on line 40.
                   typedArgs = harmonizedArgs
@@ -1448,20 +1448,23 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         defn.isValueSubType(cls.typeRef, sup) &&
         !(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
-      ts.mapConserve { t =>
+      val ts1 = ts.mapConserve { t =>
         tpe(t).widenTermRefExpr match {
           case ct: ConstantType => adapt(t, lub)
           case _ => t
         }
       }
+      if (numericClasses(ts1, Set()).size == 1) ts1 else ts
     }
     else ts
   }
 
   /** If `trees` all have numeric value types, and they do not have all the same type,
-   *  pick a common numeric supertype and convert all trees to this type.
+   *  pick a common numeric supertype and convert all constant trees to this type.
+   *  If the resulting trees all have the same type, return them instead of the original ones.
    */
   def harmonize(trees: List[Tree])(implicit ctx: Context): List[Tree] = {
     def adapt(tree: Tree, pt: Type): Tree = tree match {
@@ -1472,7 +1475,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   }
 
   /** If all `types` are numeric value types, and they are not all the same type,
-   *  pick a common numeric supertype and return it instead of every original type.
+   *  pick a common numeric supertype and widen any constant types in `tpes` to it.
+   *  If the resulting types are all the same, return them instead of the original ones.
    */
   private def harmonizeTypes(tpes: List[Type])(implicit ctx: Context): List[Type] =
     harmonizeWith(tpes)(identity, (tp, pt) => pt)

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

@@ -0,0 +1,78 @@
+---
+layout: doc-page
+title: Dropped: Weak Conformance
+---
+
+In some situations, Scala used a {\em weak conformance} relation when
+testing type compatibility or computing the least upper bound of a set
+of types.  The principal motivation behind weak conformance was to
+make as expression like this have type `List[Double]`:
+
+    List(1.0, math.sqrt(3.0), 0, -3.3) // : List[Double]
+
+It's "obvious" that this should be a `List[Double]`. However, without
+some special provision, the least upper bound of the lists's element
+types `(Double, Double, Int, Double)` would be `AnyVal`, hence the list
+expression would be given type `List[AnyVal]`.
+
+A less obvious example is the following one, which was also typed as a
+`List[Double]`, using the weak conformance relation.
+
+    val n: Int = 3
+    val c: Char = 'X'
+    val n: Double = math.sqrt(3.0)
+    List(n, c, d) // used to be: List[Double], now: List[AnyVal]
+
+Here, it is less clear why the type should be widened to
+`List[Double]`, a `List[AnyVal` seems to be an equally valid -- and
+more principled -- choice.
+
+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 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: Every
+   constant expression `E` in `Es` is widened to the least primitive
+   numeric value type above the types of all expressions in `Es`. Here
+   _above_ and _least_ are interpreted according to the ordering given
+   below.
+
+
+                  Double
+                 /      \
+               Long    Float
+                 \     /
+                   Int
+                 /    \
+              Short   Char
+                |
+              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.
+
+__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.
+
+

docs/sidebar.yml

@@ -95,6 +95,8 @@ sidebar:
               url: docs/reference/dropped/xml.html
             - title: Auto-Application
               url: docs/reference/dropped/auto-apply.html
+            - title: Weak Conformance
+              url: docs/reference/dropped/weak-conformance.html
     - title: Contributing
       subsection:
         - title: Getting Started