Treat Refinements more like AndTypes

Fixes #12306

When comparing with an AndType on the left and a RefinedType on the right,
decompose the right hand side into an AndType of types that have a single
refinement each. This makes sure we lose the least information in the
necessary subsequent `either` call.

Author: odersky

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

@@ -570,10 +570,19 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           if ((skipped2 eq tp2) || !Config.fastPathForRefinedSubtype)
             tp1 match {
               case tp1: AndType =>
-                // Delay calling `compareRefinedSlow` because looking up a member
-                // of an `AndType` can lead to a cascade of subtyping checks
-                // This twist is needed to make collection/generic/ParFactory.scala compile
-                fourthTry || compareRefinedSlow
+                // TODO: this should really be an in depth analysis whether LHS contains
+                // an AndType, or has an AndType as bound. What matters is to predict
+                // whether we will be forced into an either later on.
+                tp2.parent match
+                  case _: RefinedType | _: AndType =>
+                    // maximally decompose RHS to limit the bad effects of the `either` that is necessary
+                    // since LHS is an AndType
+                    recur(tp1, decomposeRefinements(tp2, Nil))
+                  case _ =>
+                    // Delay calling `compareRefinedSlow` because looking up a member
+                    // of an `AndType` can lead to a cascade of subtyping checks
+                    // This twist is needed to make collection/generic/ParFactory.scala compile
+                    fourthTry || compareRefinedSlow
               case tp1: HKTypeLambda =>
                 // HKTypeLambdas do not have members.
                 fourthTry
@@ -1691,6 +1700,15 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     else op2
   end necessaryEither
 
+  /** Decompose into conjunction of types each of which has only a single refinement */
+  def decomposeRefinements(tp: Type, refines: List[(Name, Type)]): Type = tp match
+    case RefinedType(parent, rname, rinfo) =>
+      decomposeRefinements(parent, (rname, rinfo) :: refines)
+    case AndType(tp1, tp2) =>
+      AndType(decomposeRefinements(tp1, refines), decomposeRefinements(tp2, refines))
+    case _ =>
+      refines.map(RefinedType(tp, _, _): Type).reduce(AndType(_, _))
+
   /** Does type `tp1` have a member with name `name` whose normalized type is a subtype of
    *  the normalized type of the refinement `tp2`?
    *  Normalization is as follows: If `tp2` contains a skolem to its refinement type,

tests/pos/i12306.scala

@@ -0,0 +1,22 @@
+class Record(elems: Map[String, Any]) extends Selectable:
+  val fields = elems.toMap
+  def selectDynamic(name: String): Any = fields(name)
+
+extension [A <: Record] (a:A) {
+  def join[B <: Record] (b:B): A & B = {
+    Record(a.fields ++ b.fields).asInstanceOf[A & B]
+  }
+}
+
+type Person = Record { val name: String; val age: Int }
+type Child = Record { val parent: String }
+type PersonAndChild = Record { val name: String; val age: Int; val parent: String }
+
+@main def hello = {
+  val person = Record(Map("name" -> "Emma", "age" -> 42)).asInstanceOf[Person]
+  val child = Record(Map("parent" -> "Alice")).asInstanceOf[Child]
+  val personAndChild = person.join(child)
+
+  val v1: PersonAndChild = personAndChild
+  val v2: PersonAndChild = person.join(child)
+}