Optimize typeParams

Direct encoding of lazy val; make typeParams tail recursive.

Author: odersky

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

@@ -18,6 +18,7 @@ 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 {
@@ -168,31 +169,32 @@ 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") /*<|<*/ {
-    self match {
+    @tailrec def recur(tp: Type): List[TypeParamInfo] = tp match {
       case self: TypeRef =>
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
-        else if (!tsym.exists) self.info.typeParams
+        else if (!tsym.exists) recur(self.info)
         else tsym.infoOrCompleter match {
           case info: LazyType => info.completerTypeParams(tsym)
-          case info => info.typeParams
+          case info => recur(info)
         }
       case self: AppliedType =>
         if (self.tycon.typeSymbol.isClass) Nil
-        else self.superType.typeParams
+        else recur(self.superType)
       case self: ClassInfo =>
         self.cls.typeParams
       case self: HKTypeLambda =>
         self.typeParams
       case _: SingletonType | _: RefinedType | _: RecType =>
         Nil
       case self: WildcardType =>
-        self.optBounds.typeParams
+        recur(self.optBounds)
       case self: TypeProxy =>
-        self.superType.typeParams
+        recur(self.superType)
       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,8 +3007,13 @@ object Types {
 
     def newParamRef(n: Int) = new TypeParamRef(this, n) {}
 
-    lazy val typeParams: List[LambdaParam] =
-      paramNames.indices.toList.map(new LambdaParam(this, _))
+    private var myTypeParams: List[LambdaParam] = null
+
+    lazy val typeParams: List[LambdaParam] = {
+      if (myTypeParams == null)
+        myTypeParams = paramNames.indices.toList.map(new LambdaParam(this, _))
+      myTypeParams
+    }
 
     def derivedLambdaAbstraction(paramNames: List[TypeName], paramInfos: List[TypeBounds], resType: Type)(implicit ctx: Context): Type =
       resType match {