safe_&: handle higher-kinded arguments like regular &

Unfortunately, i9346.scala has to be put in pending because it
still crashes (due to a cycle involving a LazyRef) after this fix, and
because `safe_&` is only called from `recoverable_&` when there is some
sort of cycle in the first place, I haven't been able to make another
testcase that exercises this codepath.

It would be good if we could figure out how to get i9346.scala to
compile (see also #9346 for discussions). It is is a minimization of a
pattern heavily used in akka-stream, similar to the use of the `CC` type
parameter in the scala-library collections but using a type member
instead. Unfortunately, it seems that Dotty is not really prepared to
handle F-bounds in type members currently. I was able to get the
testcase as well as akka-stream to compile by tweaking `findMember` to
not compute an intersection when the refinement is an alias:

```diff
--- compiler/src/dotty/tools/dotc/core/Types.scala
+++ compiler/src/dotty/tools/dotc/core/Types.scala
@@ -671,7 +671,8 @@ object Types {
         val rinfo = tp.refinedInfo
         if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
           val jointInfo =
-            if (ctx.base.pendingMemberSearches.contains(name)) pinfo safe_& rinfo
+            if (rinfo.isInstanceOf[TypeAlias]) rinfo
+            else if (ctx.base.pendingMemberSearches.contains(name)) pinfo safe_& rinfo
             else pinfo recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         }
```

This seems to work, but to be sound it means that we need to check for
invalid bounds in PostTyper (see tests/neg/i5556.scala for an example
where this matters), like we do for type parameters in
`checkAppliedType`.

Author: smarter

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

@@ -2078,7 +2078,7 @@ class TypeComparer(using val comparerCtx: Context) extends ConstraintHandling wi
    *
    *    [X1, ..., Xn] -> op(tp1[X1, ..., Xn], tp2[X1, ..., Xn])
    */
-  private def liftIfHK(tp1: Type, tp2: Type,
+  def liftIfHK(tp1: Type, tp2: Type,
       op: (Type, Type) => Type, original: (Type, Type) => Type, combineVariance: (Variance, Variance) => Variance) = {
     val tparams1 = tp1.typeParams
     val tparams2 = tp2.typeParams

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

@@ -1018,8 +1018,11 @@ object Types {
      */
     def safe_& (that: Type)(using Context): Type = (this, that) match {
       case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
-        TypeBounds(OrType(lo1.stripLazyRef, lo2.stripLazyRef), AndType(hi1.stripLazyRef, hi2.stripLazyRef))
-      case _ => this & that
+        TypeBounds(
+           OrType.makeHk(lo1.stripLazyRef, lo2.stripLazyRef),
+          AndType.makeHk(hi1.stripLazyRef, hi2.stripLazyRef))
+      case _ =>
+        this & that
     }
 
     /** `this & that`, but handle CyclicReferences by falling back to `safe_&`.
@@ -2934,6 +2937,10 @@ object Types {
         tp2
       else
         if (checkValid) apply(tp1, tp2) else unchecked(tp1, tp2)
+
+    /** Like `make`, but also supports higher-kinded types as argument */
+    def makeHk(tp1: Type, tp2: Type)(using Context): Type =
+      ctx.typeComparer.liftIfHK(tp1, tp2, AndType.make(_, _, checkValid = false), makeHk, _ | _)
   }
 
   abstract case class OrType(tp1: Type, tp2: Type) extends AndOrType {
@@ -3020,6 +3027,10 @@ object Types {
     def make(tp1: Type, tp2: Type)(using Context): Type =
       if (tp1 eq tp2) tp1
       else apply(tp1, tp2)
+
+    /** Like `make`, but also supports higher-kinded types as argument */
+    def makeHk(tp1: Type, tp2: Type)(using Context): Type =
+      ctx.typeComparer.liftIfHK(tp1, tp2, OrType(_, _), makeHk, _ & _)
   }
 
   /** An extractor object to pattern match against a nullable union.

tests/pending/pos/i9346.scala

@@ -0,0 +1,9 @@
+trait Foo[+A] {
+  type Repr[+O] <: Foo[O] {
+    type Repr[+OO] = Foo.this.Repr[OO]
+  }
+
+  def foo: Repr[A]
+
+  def bar: Repr[A] = this.foo.foo
+}