Special case intersecting for Singleton

Singleton is not part of the normal type hierarchy, special
treatment in requiered in intersecting to avoid making incorrect
assumptions.

Author: OlivierBlanvillain

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

@@ -1920,6 +1920,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
       sym.children.map(x => ctx.refineUsingParent(tp, x)).filter(_.exists)
 
     (tp1.dealias, tp2.dealias) match {
+      case (tp1: TypeRef, tp2: TypeRef) if tp1.symbol == defn.SingletonClass || tp2.symbol == defn.SingletonClass =>
+        true
       case (tp1: ConstantType, tp2: ConstantType) =>
         tp1 == tp2
       case (tp1: TypeRef, tp2: TypeRef) if tp1.symbol.isClass && tp2.symbol.isClass =>

tests/neg/6314.scala

@@ -1,9 +1,11 @@
-object G {
-  final class X
-  final class Y
+final class X
+final class Y
 
+object Test1 {
   trait Test {
     type Type
+    // This is testing that both permutations of the types in a &
+    // are taken into account by the intersection test
     val i: Bar[Y & Type] = 1 // error
   }
 
@@ -12,3 +14,35 @@ object G {
     case Y => Int
   }
 }
+
+object Test2 {
+  trait Wizzle[L <: Int with Singleton] {
+    type Bar[A] = A match {
+      case 0 => String
+      case L => Int
+    }
+
+    // This is testing that we don't make wrong assumptions about Singleton
+    def right(fa: Bar[L]): Int = fa // error
+  }
+
+  trait Wazzlo[L <: Int with AnyVal] {
+    type Bar[A] = A match {
+      case 0 => String
+      case L => Int
+    }
+
+    // This is testing that we don't make wrong assumptions about AnyVal
+    def right(fa: Bar[L]): Int = fa // error
+  }
+
+  trait Wuzzlu[L <: String with AnyRef] {
+    type Bar[A] = A match {
+      case "" => String
+      case L => Int
+    }
+
+    // This is testing that we don't make wrong assumptions about AnyRef
+    def right(fa: Bar[L]): Int = fa // error
+  }
+}