Avoid infinite recursion when comparing recursive types.

The previous scheme goes into an infinite recursion if the recursive type
does not contain a reference to itself.

Also, make typeParams more defensive

The problematic case is something like

    { z => CC { type hk$0 = z.hk$0; type(param) hk$0 }

Here $hk0 becomes a type parameter through CC and the type lambda.
It's true that such types are eliminated later on. But we want to
avoid mispredictions at all points.

1 files changed, 2 insertions, 2 deletions

diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index 6fc1fb9dc..fc8876d09 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -364,9 +364,9 @@ class TypeApplications(val self: Type) extends AnyVal {
           val sym = self.parent.classSymbol
           if (sym.isLambdaTraitOBS) return sym.typeParams
         }
-        val precedingParams = self.parent.typeParams
+        val precedingParams = self.parent.typeParams.filterNot(_.memberName == self.refinedName)
         if (Config.newHK && self.isTypeParam) precedingParams :+ self
-        else precedingParams.filterNot(_.memberName == self.refinedName)
+        else precedingParams
       case self: RecType =>
         self.parent.typeParams
       case self: SingletonType =>