widenUnion now also widens Singletons

This relieves some of the load of `join` and offers more opportunities
to improve union types by constraining further. Without this step
we might lose some improvements compared to the situation before
where we always widened singletons in OrTypes. I don't have a test
case that demonstrates the difference, though.

Author: odersky

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -276,10 +276,11 @@ trait ConstraintHandling[AbstractContext] {
    *   1. If `inst` is a singleton type, or a union containing some singleton types,
    *      widen (all) the singleton type(s), provied the result is a subtype of `bound`
    *      (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint)
-   *      and `bound` is not a subtype of `scala.Singleton`.
    *   2. If `inst` is a union type, approximate the union type from above by an intersection
    *      of all common base types, provied the result is a subtype of `bound`.
    *
+   *  Don't do these widenings if `bound` is a subtype of `scala.Singleton`.
+   *
    * At this point we also drop the @Repeated annotation to avoid inferring type arguments with it,
    * as those could leak the annotation to users (see run/inferred-repeated-result).
    */
@@ -288,13 +289,14 @@ trait ConstraintHandling[AbstractContext] {
       val tpw = tp.widenUnion
       if ((tpw ne tp) && tpw <:< bound) tpw else tp
     }
-    def widenSingle(tp: Type) =
-      if (isSubTypeWhenFrozen(bound, defn.SingletonType)) tp
-      else {
-        val tpw = tp.widenSingletons
-        if ((tpw ne tp) && tpw <:< bound) tpw else tp
-      }
-    widenOr(widenSingle(inst)).dropRepeatedAnnot
+    def widenSingle(tp: Type) = {
+      val tpw = tp.widenSingletons
+      if ((tpw ne tp) && tpw <:< bound) tpw else tp
+    }
+    val wideInst =
+      if (isSubTypeWhenFrozen(bound, defn.SingletonType)) inst
+      else widenOr(widenSingle(inst))
+    wideInst.dropRepeatedAnnot
   }
 
   /** The instance type of `param` in the current constraint (which contains `param`).

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1033,7 +1033,8 @@ object Types {
       case _ => this
     }
 
-    /** If this type contains embedded union types, replace them by their joins.
+    /** Widen this type and if the result contains embedded union types, replace
+     *  them by their joins.
      *  "Embedded" means: inside intersectons or recursive types, or in prefixes of refined types.
      *  If an embedded union is found, we first try to simplify or eliminate it by
      *  re-lubbing it while allowing type parameters to be constrained further.
@@ -1046,7 +1047,7 @@ object Types {
      *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
      *  instead of `ArrayBuffer[_ >: Int | A <: Int & A]`
      */
-    def widenUnion(implicit ctx: Context): Type = this match {
+    def widenUnion(implicit ctx: Context): Type = widen match {
       case OrType(tp1, tp2) =>
         ctx.typeComparer.lub(tp1.widenUnion, tp2.widenUnion, canConstrain = true) match {
           case union: OrType => union.join

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

@@ -1326,7 +1326,7 @@ class Namer { typer: Typer =>
         val tp1 = tp.widenTermRefExpr match {
           case ctp: ConstantType if isInlineVal => ctp
           case ref: TypeRef if ref.symbol.is(ModuleClass) => tp
-          case _ => tp.widen.widenUnion
+          case _ => tp.widenUnion
         }
         tp1.dropRepeatedAnnot
       }