Move retry logic to one special case in typeParams

Author: odersky

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

@@ -182,7 +182,17 @@ class TypeApplications(val self: Type) extends AnyVal {
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
         else tsym.infoOrCompleter match {
-          case info: LazyType if isTrivial(self.prefix, tsym) => info.completerTypeParams(tsym)
+          case info: LazyType if isTrivial(self.prefix, tsym) =>
+            val tparams = info.completerTypeParams(tsym)
+            if tsym.isCompleted then tsym.info.typeParams
+              // Completers sometimes represent parameters as symbols where
+              // the completed type represents them as paramrefs. Make sure we get
+              // a stable result by calling `typeParams` recursively. Test case
+              // is pos/i19942.scala, where parameter F0 has initially a Namer#TypeDefCompleter.
+              // After calling its completerTypeParams, we get a list of parameter symbols
+              // and as a side effect F0 is completed. Calling typeParams on the completed
+              // type gives a list of paramrefs.
+            else tparams
           case _ => self.info.typeParams
         }
       case self: AppliedType =>

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

@@ -4281,16 +4281,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     def adaptType(tp: Type): Tree = {
       val tree1 =
-        if pt eq AnyTypeConstructorProto then tree
-        else if tp.typeParamSymbols.isEmpty || tp.typeParamSymbols.isEmpty then
-          // call typeParamSymbols twice, to get the stable results
-          // (see also note inside typeParamSymbols)
-          // given `type LifecycleF = [_] =>> Any` in pos/i19942.scala
-          // with an Ident of LifecycleF, calling typeParams will return:
-          // 1. [type _] a list of the symbol _ in the type def tree, on the first call
-          // 2. [+_] a list of a lambda param, afterwards
-          // we only want to eta-expand if there are real type param symbols, so we check twice
-          tree
+        if (pt eq AnyTypeConstructorProto) || tp.typeParamSymbols.isEmpty then tree
         else {
           if (ctx.isJava)
             // Cook raw type

tests/neg-macros/quote-type-variable-no-inference-3.check

@@ -1,10 +1,10 @@
 -- Warning: tests/neg-macros/quote-type-variable-no-inference-3.scala:5:22 ---------------------------------------------
 5 |    case '{ $_ : F[t, t]; () } => // warn // error
   |                      ^
-  |                      Ignored bound <: Comparable[U]
+  |                      Ignored bound <: Comparable[Any]
   |
   |                      Consider defining bounds explicitly:
-  |                        '{ type t <: Comparable[U]; ... }
+  |                        '{ type t <: Comparable[Any]; ... }
 -- Warning: tests/neg-macros/quote-type-variable-no-inference-3.scala:6:49 ---------------------------------------------
 6 |    case '{ type u <: Comparable[`u`]; $_ : F[u, u] } =>
   |                                                 ^