Partial revert of Optimize typeParams

(reverted from commit a1ce848)

It turns out the previous typeParams is already fully optimized, no need
to add a local function. We just keep the change to how typeParams are
cached in type lambdas (fixing an accidental lazy val to a def).

Author: odersky

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

@@ -18,7 +18,6 @@ import util.Positions.Position
 import config.Printers.{core, typr}
 import collection.mutable
 import dotty.tools.dotc.config.Config
-import annotation.tailrec
 import java.util.NoSuchElementException
 
 object TypeApplications {
@@ -169,32 +168,31 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  any type parameter that is-rebound by the refinement.
    */
   final def typeParams(implicit ctx: Context): List[TypeParamInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
-    @tailrec def recur(tp: Type): List[TypeParamInfo] = tp match {
+    self match {
       case self: TypeRef =>
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
-        else if (!tsym.exists) recur(self.info)
+        else if (!tsym.exists) self.info.typeParams
         else tsym.infoOrCompleter match {
           case info: LazyType => info.completerTypeParams(tsym)
-          case info => recur(info)
+          case info => info.typeParams
         }
       case self: AppliedType =>
         if (self.tycon.typeSymbol.isClass) Nil
-        else recur(self.superType)
+        else self.superType.typeParams
       case self: ClassInfo =>
         self.cls.typeParams
       case self: HKTypeLambda =>
         self.typeParams
       case _: SingletonType | _: RefinedType | _: RecType =>
         Nil
       case self: WildcardType =>
-        recur(self.optBounds)
+        self.optBounds.typeParams
       case self: TypeProxy =>
-        recur(self.superType)
+        self.superType.typeParams
       case _ =>
         Nil
     }
-    recur(self)
   }
 
   /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */

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

@@ -3007,9 +3007,9 @@ object Types {
 
     def newParamRef(n: Int) = new TypeParamRef(this, n) {}
 
-    private var myTypeParams: List[LambdaParam] = null
+    private[this] var myTypeParams: List[LambdaParam] = null
 
-    lazy val typeParams: List[LambdaParam] = {
+    def typeParams: List[LambdaParam] = {
       if (myTypeParams == null)
         myTypeParams = paramNames.indices.toList.map(new LambdaParam(this, _))
       myTypeParams