Optimize stripTypeVar, stripAnnots combinations v3

Use overrides as for stripTypeVar and stripAnnots, but combine the two
in one method

Author: odersky

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

@@ -181,7 +181,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 +196,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
@@ -369,7 +369,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 +1070,12 @@ 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
+
     def rewrapAnnots(tp: Type)(using Context): Type = tp.stripTypeVar match {
       case AnnotatedType(tp1, annot) => AnnotatedType(rewrapAnnots(tp1), annot)
       case _ => this
@@ -1105,7 +1108,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 +1117,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
     }
@@ -4302,6 +4305,8 @@ object Types {
       if (inst.exists) inst.stripTypeVar else origin
     }
 
+    override def stripped(using Context): Type = stripTypeVar.stripped
+
     /** If the variable is instantiated, its instance, otherwise its origin */
     override def underlying(using Context): Type = {
       val inst = instanceOpt
@@ -4705,6 +4710,8 @@ object Types {
 
     override def stripAnnots(using Context): Type = parent.stripAnnots
 
+    override def stripped(using Context): Type = parent.stripped
+
     private var isRefiningKnown = false
     private var isRefiningCache: Boolean = _
 

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) + (