Optimize stripTypeVar, stripAnnots combinations

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,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 +1107,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 +1116,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
     }
@@ -1805,6 +1807,9 @@ object Types {
       if (hash == NotCached) System.identityHashCode(this) else hash
   }
 
+  abstract class StrippableProxyType extends CachedProxyType:
+    override def stripped(using Context): Type = stripAnnots.stripTypeVar.stripped
+
   /**  Instances of this class are uncached and are not proxies. */
   abstract class UncachedGroundType extends Type {
     final def hash: Int = NotCached
@@ -4198,7 +4203,7 @@ object Types {
    *  @param  origin        The parameter that's tracked by the type variable.
    *  @param  creatorState  The typer state in which the variable was created.
    */
-  final class TypeVar private(initOrigin: TypeParamRef, creatorState: TyperState, nestingLevel: Int) extends CachedProxyType with ValueType {
+  final class TypeVar private(initOrigin: TypeParamRef, creatorState: TyperState, nestingLevel: Int) extends StrippableProxyType with ValueType {
 
     private var currentOrigin = initOrigin
 
@@ -4692,7 +4697,7 @@ object Types {
   // ----- Annotated and Import types -----------------------------------------------
 
   /** An annotated type tpe @ annot */
-  abstract case class AnnotatedType(parent: Type, annot: Annotation) extends CachedProxyType with ValueType {
+  abstract case class AnnotatedType(parent: Type, annot: Annotation) extends StrippableProxyType with ValueType {
 
     override def underlying(using Context): Type = parent
 

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