Optimize stripTypeVar, stripAnnots combinations without creating abstract class

Author: odersky

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

@@ -163,12 +163,11 @@ object Types {
       * Like in isStableMember, "stability" means idempotence.
       * Rationale: If an expression has a stable type, the expression must be idempotent, so stable types
       * must be singleton types of stable expressions. */
-    final def isStable(using Context): Boolean = stripTypeVar match {
+    final def isStable(using Context): Boolean = stripped match {
       case tp: TermRef => tp.symbol.isStableMember && tp.prefix.isStable || tp.info.isStable
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
-      case tp: AnnotatedType => tp.parent.isStable
       case tp: AndType =>
         tp.tp1.isStable && (realizability(tp.tp2) eq Realizable) ||
         tp.tp2.isStable && (realizability(tp.tp1) eq Realizable)
@@ -181,7 +180,7 @@ object Types {
      *        It makes no sense for it to be an alias type because isRef would always
      *        return false in that case.
      */
-    def isRef(sym: Symbol, skipRefined: Boolean = true)(using Context): Boolean = stripAnnots.stripTypeVar match {
+    def isRef(sym: Symbol, skipRefined: Boolean = true)(using Context): Boolean = stripped match {
       case this1: TypeRef =>
         this1.info match { // see comment in Namer#typeDefSig
           case TypeAlias(tp) => tp.isRef(sym, skipRefined)
@@ -196,7 +195,7 @@ object Types {
       case _ => false
     }
 
-    /** Is this type a (neither aliased nor applied) reference to class `sym`? */
+    /** Is this type a (neither aliased nor applied nor annotated) reference to class `sym`? */
     def isDirectRef(sym: Symbol)(using Context): Boolean = stripTypeVar match {
       case this1: TypeRef =>
         this1.name == sym.name && // avoid forcing info if names differ
@@ -214,7 +213,7 @@ object Types {
     /** Does this type refer exactly to class symbol `sym`, instead of to a subclass of `sym`?
      *  Implemented like `isRef`, but follows more types: all type proxies as well as and- and or-types
      */
-    private[Types] def isTightPrefix(sym: Symbol)(using Context): Boolean = stripTypeVar match {
+    private[Types] def isTightPrefix(sym: Symbol)(using Context): Boolean = stripped match {
       case tp: NamedType => tp.info.isTightPrefix(sym)
       case tp: ClassInfo => tp.cls eq sym
       case tp: Types.ThisType => tp.cls eq sym
@@ -369,7 +368,7 @@ object Types {
 
     /** Is this a match type or a higher-kinded abstraction of one?
      */
-    def isMatch(using Context): Boolean = stripTypeVar.stripAnnots match {
+    def isMatch(using Context): Boolean = stripped match {
       case _: MatchType => true
       case tp: HKTypeLambda => tp.resType.isMatch
       case _ => false
@@ -1070,9 +1069,15 @@ object Types {
     def stripTypeVar(using Context): Type = this
 
     /** Remove all AnnotatedTypes wrapping this type.
-      */
+     */
     def stripAnnots(using Context): Type = this
 
+    /** Strip TypeVars and Annotation wrappers */
+    def stripped(using Context): Type = this match
+      case tp: TypeVar => tp.stripTypeVar.stripped
+      case tp: AnnotatedType => tp.parent.stripped
+      case _ => this
+
     def rewrapAnnots(tp: Type)(using Context): Type = tp.stripTypeVar match {
       case AnnotatedType(tp1, annot) => AnnotatedType(rewrapAnnots(tp1), annot)
       case _ => this
@@ -1105,7 +1110,7 @@ object Types {
       case tp: SingletonType => tp.underlying.widen
       case tp: ExprType => tp.resultType.widen
       case tp =>
-        val tp1 = tp.stripTypeVar.stripAnnots
+        val tp1 = tp.stripped
         if tp1 eq tp then tp
         else
           val tp2 = tp1.widen
@@ -1114,7 +1119,7 @@ object Types {
     /** Widen from singleton type to its underlying non-singleton
      *  base type by applying one or more `underlying` dereferences.
      */
-    final def widenSingleton(using Context): Type = stripTypeVar.stripAnnots match {
+    final def widenSingleton(using Context): Type = stripped match {
       case tp: SingletonType if !tp.isOverloaded => tp.underlying.widenSingleton
       case _ => this
     }

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -691,7 +691,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       case _ => tp.show
     }
 
-    def refine(tp: Type): String = tp.stripAnnots.stripTypeVar match {
+    def refine(tp: Type): String = tp.stripped match {
       case tp: RefinedType => refine(tp.parent)
       case tp: AppliedType =>
         refine(tp.typeConstructor) + (