Reduce projections of type aliases with class type prefixes

Projections P # X are types that we would like to avoid. If X
is a class type, there's nothing we can do. If X is an abstract type,
we use skolemization and rewrite to (x?: P).X. If X is an alias
type we should simply dealias but this was not done before.

This caused an exonential blowup in #19892, where we costructed types
of the form

   ZPartialServerEndpoint[R, A, B, I, E, O, -C] # EndpointType[A, I, E, T, R] ... # EndpointType[A, I, E, T, R]

When the were 5 or more such selections, sompile times blew up (33s for 5, timeout after 5 minutes for 6).
I am still not qute sure where the blowup happened. Looking at stacktraces of random interrups
it seemed to be in a deep recursion of memberDenot and asSeenFrom calls.I believe it would still
be interesting to find out more about this, in case there are other similar situations where combinations
of deep projections with wide applications cannot be avoided.

But for this precise problem, eagerly dealising fixes it.

[Cherry-picked cd04d00][modified]

Author: WojciechMazur

Diff for: compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2589,14 +2589,22 @@ object Types extends TypeUtils {
       case _ => true
     }
 
-    /** Reduce a type-ref `T { X = U; ... } # X`  to   `U`
-     *  provided `U` does not refer with a RecThis to the
-     *  refinement type `T { X = U; ... }`
+    /** Reduce a type ref P # X, where X is a type alias and P is a refined type or
+     *  a class type. If P is a refined type `T { X = U; ... }`, reduce P to U,
+     *  provided U does not refer with a RecThis to the same refined type. If P is a
+     *  class type, reduce it to the dealiasd version of P # X. This means that at typer
+     *  we create projections only for inner classes with class prefixes, since projections
+     *  of P # X where X is an abstract type are handled by skolemization. At later phases
+     *  these projections might arise, though.
      */
     def reduceProjection(using Context): Type =
       if (isType) {
         val reduced = prefix.lookupRefined(name)
-        if (reduced.exists) reduced else this
+        if reduced.exists then reduced
+        else prefix.stripTypeVar match
+          case pre: (AppliedType | TypeRef)
+          if prefix.typeSymbol.isClass && this.symbol.isAliasType => dealias
+          case _ => this
       }
       else this
 

Diff for: compiler/test/dotc/pos-test-pickling.blacklist

@@ -105,3 +105,7 @@ java-inherited-type1
 
 # recursion limit exceeded
 i7445b.scala
+
+# more aggresive reduce projection makes a difference
+i15525.scala
+

Diff for: tests/pos/i19892.scala

@@ -0,0 +1,26 @@
+abstract class ZPartialServerEndpoint[R, A, B, I, E, O, -C]
+    extends EndpointOps[A, I, E, O, C]{
+  override type ThisType[-_R] = ZPartialServerEndpoint[R, A, B, I, E, O, _R]
+  override type EndpointType[_A, _I, _E, _O, -_R] =ZPartialServerEndpoint[R, _A, B, _I, _E, _O, _R]
+}
+
+trait EndpointOps[A, I, E, O, -R] {
+  type EndpointType[_A, _I, _E, _O, -_R]
+  type ThisType[-_R]
+  def out[T]: EndpointType[A, I, E, T, R]
+  def description(d: String): ThisType[R]
+}
+
+object Test {
+  def basicEndpoint[R](): ZPartialServerEndpoint[R, Any, Any, Unit, Any, Unit, Any] = ???
+
+  // commonts next to `.out[Any]` contain information about compilation time when chaining up to N `out` functions
+  val case1 =
+     basicEndpoint() // 1.5s
+        .out[Any] // 1.6s
+        .out[Any] // 1.7s
+        .out[Any] // 2s
+        .out[Any] // 4s
+        .out[Any] // 33s
+        .out[Any] // aborted after 5 min
+}