Don't widen instance if bound is subtype of Singleton

This was the situation before the PR. I thought that simply checking whether
the instance is a subtype of the bound is equivalent, but compare-singletons.scala
shows that this is not the case. Here, we have a type variable X such that
`r.type <:< X <:< Singleton` where `r: R` and `R <: Singleton`. With the
previous changes in this PR, we instantiate `X` to `R`. With the revert
in this commit we instantiate it to `r.type` instead.

Author: odersky

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

@@ -275,19 +275,26 @@ trait ConstraintHandling[AbstractContext] {
   /** Widen inferred type `inst` with upper `bound`, according to the following rules:
    *   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).
+   *      (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`.
    *
    * 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).
    */
   def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type = {
-    def tryWiden(tp: Type, widen: Type => Type) = {
-      val tpw = widen(tp)
+    def widenOr(tp: Type) = {
+      val tpw = tp.widenUnion
       if ((tpw ne tp) && tpw <:< bound) tpw else tp
     }
-    tryWiden(tryWiden(inst, _.widenSingletons), _.widenUnion).dropRepeatedAnnot
+    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
   }
 
   /** The instance type of `param` in the current constraint (which contains `param`).

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

@@ -1046,7 +1046,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 = widen match {
+    def widenUnion(implicit ctx: Context): Type = this match {
       case OrType(tp1, tp2) =>
         ctx.typeComparer.lub(tp1.widenUnion, tp2.widenUnion, canConstrain = true) match {
           case union: OrType => union.join

tests/pos/compare-singletons.scala

@@ -0,0 +1,12 @@
+class Refl {
+  type S
+}
+
+class A[R <: Refl & Singleton](val r: R) {
+  def s: r.S = ???
+}
+
+class B[R <: Refl & Singleton](val r: R) {
+  val a = new A(r)
+  val s: r.S = a.s
+}