Adapt context-bound-companion logic to use AndType of AppliedTypes

Instead of AppliedType of OrTypes, which relied on the distribution of AndTypes
when inheriting multiple context bound companions of the same name

Author: EugeneFlesselle

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

@@ -460,7 +460,7 @@ class Definitions {
   @tu lazy val CBCompanion: TypeSymbol = // type `<context-bound-companion>`[-Refs]
     enterPermanentSymbol(tpnme.CBCompanion,
       TypeBounds(NothingType,
-        HKTypeLambda(tpnme.syntheticTypeParamName(0) :: Nil, Contravariant :: Nil)(
+        HKTypeLambda(tpnme.syntheticTypeParamName(0) :: Nil)(
           tl => TypeBounds.empty :: Nil,
           tl => AnyType))).asType
 

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

@@ -307,7 +307,7 @@ object NamerOps:
    *  The context-bound companion has as name the name of `tsym` translated to
    *  a term name. We create a synthetic val of the form
    *
-   *    val A: `<context-bound-companion>`[witnessRef1 | ... | witnessRefN]
+   *    val A: `<context-bound-companion>`[witnessRef1] & ... & `<context-bound-companion>`[witnessRefN]
    *
    *  where
    *
@@ -325,8 +325,7 @@ object NamerOps:
             prefix.select(params.find(_.name == witnessName).get)
       else
         witnessNames.map(TermRef(prefix, _))
-    val cbtype = defn.CBCompanion.typeRef.appliedTo:
-      witnessRefs.reduce[Type](OrType(_, _, soft = false))
+    val cbtype = witnessRefs.map(defn.CBCompanion.typeRef.appliedTo).reduce(AndType.apply)
     val cbc = newSymbol(
         ctx.owner, companionName,
         (tsym.flagsUNSAFE & (AccessFlags)).toTermFlags | Synthetic,

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

@@ -88,7 +88,7 @@ class SymUtils:
     }
 
     def isContextBoundCompanion(using Context): Boolean =
-      self.is(Synthetic) && self.infoOrCompleter.typeSymbol == defn.CBCompanion
+      self.is(Synthetic) && self.infoOrCompleter.isContextBoundCompanion
 
     def isDummyCaptureParam(using Context): Boolean =
       self.isAllOf(CaptureParam) && !(self.isClass || self.is(Method))

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

@@ -466,6 +466,14 @@ object Types extends TypeUtils {
       case AppliedType(tycon: TypeRef, arg :: Nil) => defn.isInto(tycon.symbol)
       case _ => false
 
+    /** Is this type of the form `<context-bound-companion>[Ref1] & ... & <context-bound-companion>[RefN]`?
+     *  Where the intersection may be introduced by `NamerOps.addContextBoundCompanionFor`
+     *  or by inheriting multiple context bound companions for the same name.
+     */
+    def isContextBoundCompanion(using Context): Boolean = this.widen match
+      case AndType(tp1, tp2) => tp1.isContextBoundCompanion.ensuring(_ == tp2.isContextBoundCompanion)
+      case tp => tp.typeSymbol == defn.CBCompanion
+
     /** Is this type a legal target type for an implicit conversion, so that
      *  no `implicitConversions` language import is necessary?
      */

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

@@ -928,7 +928,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     // Otherwise, if the qualifier is a context bound companion, handle
     // by selecting a witness in typedCBSelect
     def tryCBCompanion() =
-      if qual.tpe.typeSymbol == defn.CBCompanion then
+      if qual.tpe.isContextBoundCompanion then
         typedCBSelect(tree0, pt, qual)
       else EmptyTree
 
@@ -997,13 +997,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      *  alternatives referred to by `witnesses`.
      *  @param prevs      a list of (ref tree, typer state, term ref) tripls that
      *                    represents previously identified alternatives
-     *  @param witnesses  a type of the form ref_1 | ... | ref_n containing references
+     *  @param witnesses  a type of the form `isContextBoundCompanion` containing references
      *                    still to be considered.
      */
-    def tryAlts(prevs: Alts, witnesses: Type): Alts = witnesses match
-      case OrType(wit1, wit2) =>
+    def tryAlts(prevs: Alts, witnesses: Type): Alts = witnesses.widen match
+      case AndType(wit1, wit2) =>
         tryAlts(tryAlts(prevs, wit1), wit2)
-      case witness: TermRef =>
+      case AppliedType(_, List(witness: TermRef)) =>
         val altQual = tpd.ref(witness).withSpan(qual.span)
         val altCtx = ctx.fresh.setNewTyperState()
         val alt = typedSelectWithAdapt(tree, pt, altQual)(using altCtx)
@@ -1015,19 +1015,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           if comparisons.exists(_ == 1) then prevs
           else current :: prevs.zip(comparisons).collect{ case (prev, cmp) if cmp != -1 => prev }
 
-    qual.tpe.widen match
-      case AppliedType(_, arg :: Nil) =>
-        tryAlts(Nil, arg) match
-          case Nil => EmptyTree
-          case (best @ (bestTree, bestState, _)) :: Nil =>
-            bestState.commit()
-            bestTree
-          case multiAlts =>
-            report.error(
-              em"""Ambiguous witness reference. None of the following alternatives is more specific than the other:
-                  |${multiAlts.map((alt, _, witness) => i"\n  $witness.${tree.name}: ${alt.tpe.widen}")}""",
-              tree.srcPos)
-            EmptyTree
+    tryAlts(Nil, qual.tpe) match
+      case Nil => EmptyTree
+      case (best @ (bestTree, bestState, _)) :: Nil =>
+        bestState.commit()
+        bestTree
+      case multiAlts =>
+        report.error(
+          em"""Ambiguous witness reference. None of the following alternatives is more specific than the other:
+              |${multiAlts.map((alt, _, witness) => i"\n  $witness.${tree.name}: ${alt.tpe.widen}")}""",
+          tree.srcPos)
+        EmptyTree
   end typedCBSelect
 
   def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {

tests/pos/cb-companion-joins.scala

@@ -7,14 +7,39 @@ trait M[Self]:
 trait Num[Self]:
   def zero: Self
 
-trait A extends M[A]
-trait B extends M[A]
-
-trait AA:
-  type X: M
-trait BB:
-  type X: Num
-class CC[X1: {M, Num}] extends AA, BB:
-  type X = X1
-  X.zero
-  X.unit
+object Test1:
+  trait X extends M[X]
+  trait Y extends M[Y]
+
+object Test2:
+  trait A[X: Num]:
+    X.zero
+  trait B[X: {M, Num}]:
+    X.unit
+    X.zero
+
+object Test3:
+
+  trait A:
+    type X: M
+    X.unit
+
+  trait B:
+    type X: Num
+    X.zero
+
+  trait C extends A, B:
+    X.zero
+    X.unit
+
+  class AA[Y: M] extends A:
+    type X = Y
+    X.unit
+    Y.unit
+
+  class CC[Y: {M, Num}] extends C:
+    type X = Y
+    X.zero
+    X.unit
+    Y.zero
+    Y.unit