Refactor dealias

Refactor dealias to make it easier to add further keep conditions

Author: odersky

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

@@ -1473,48 +1473,48 @@ object Types extends TypeUtils {
             case Atoms.Unknown => Atoms.Unknown
         case _ => Atoms.Unknown
 
-    private def dealias1(keep: AnnotatedType => Context ?=> Boolean, keepOpaques: Boolean)(using Context): Type = this match {
+    def dealias(keeps: Keeps)(using Context): Type = this match
       case tp: TypeRef =>
-        if (tp.symbol.isClass) tp
-        else tp.info match {
-          case TypeAlias(alias) if !(keepOpaques && tp.symbol.is(Opaque)) =>
-            alias.dealias1(keep, keepOpaques)
+        if tp.symbol.isClass then tp
+        else tp.info match
+          case TypeAlias(alias) if (keeps & KeepOpaques) == 0 || !tp.symbol.is(Opaque) =>
+            alias.dealias(keeps)
           case _ => tp
-        }
       case app @ AppliedType(tycon, _) =>
-        val tycon1 = tycon.dealias1(keep, keepOpaques)
-        if (tycon1 ne tycon) app.superType.dealias1(keep, keepOpaques)
+        val tycon1 = tycon.dealias(keeps)
+        if tycon1 ne tycon then app.superType.dealias(keeps)
         else this
-      case tp: TypeVar =>
+      case tp: TypeVar if (keeps & KeepTypeVars) == 0 =>
         val tp1 = tp.instanceOpt
-        if (tp1.exists) tp1.dealias1(keep, keepOpaques) else tp
+        if tp1.exists then tp1.dealias(keeps) else tp
       case tp: AnnotatedType =>
-        val parent1 = tp.parent.dealias1(keep, keepOpaques)
-        if keep(tp) then tp.derivedAnnotatedType(parent1, tp.annot)
+        val parent1 = tp.parent.dealias(keeps)
+        if (keeps & KeepAnnots) != 0
+            || (keeps & KeepRefiningAnnots) != 0 && tp.isRefining
+        then tp.derivedAnnotatedType(parent1, tp.annot)
         else tp match
           case tp @ CapturingType(parent, refs) =>
             tp.derivedCapturingType(parent1, refs)
           case _ =>
             parent1
       case tp: LazyRef =>
-        tp.ref.dealias1(keep, keepOpaques)
+        tp.ref.dealias(keeps)
       case _ => this
-    }
 
     /** Follow aliases and dereference LazyRefs, annotated types and instantiated
      *  TypeVars until type is no longer alias type, annotated type, LazyRef,
      *  or instantiated type variable.
      */
-    final def dealias(using Context): Type = dealias1(keepNever, keepOpaques = false)
+    final def dealias(using Context): Type = dealias(KeepNothing)
 
     /** Follow aliases and dereference LazyRefs and instantiated TypeVars until type
      *  is no longer alias type, LazyRef, or instantiated type variable.
      *  Goes through annotated types and rewraps annotations on the result.
      */
-    final def dealiasKeepAnnots(using Context): Type = dealias1(keepAlways, keepOpaques = false)
+    final def dealiasKeepAnnots(using Context): Type = dealias(KeepAnnots)
 
     /** Like `dealiasKeepAnnots`, but keeps only refining annotations */
-    final def dealiasKeepRefiningAnnots(using Context): Type = dealias1(keepIfRefining, keepOpaques = false)
+    final def dealiasKeepRefiningAnnots(using Context): Type = dealias(KeepRefiningAnnots)
 
     /** Like dealias, but does not follow aliases if symbol is Opaque. This is
      *  necessary if we want to look at the info of a symbol containing opaque
@@ -1532,13 +1532,13 @@ object Types extends TypeUtils {
      *  Here, we dealias symbol infos at the start of capture checking in operation `fluidify`.
      *  We have to be careful not to accidentally reveal opaque aliases when doing so.
      */
-    final def dealiasKeepOpaques(using Context): Type = dealias1(keepNever, keepOpaques = true)
+    final def dealiasKeepOpaques(using Context): Type = dealias(KeepOpaques)
 
     /** Like dealiasKeepAnnots, but does not follow opaque aliases. See `dealiasKeepOpaques`
      *  for why this is sometimes necessary.
      */
     final def dealiasKeepAnnotsAndOpaques(using Context): Type =
-      dealias1(keepAlways, keepOpaques = true)
+      dealias(KeepAnnots | KeepOpaques)
 
     /** Approximate this type with a type that does not contain skolem types. */
     final def deskolemized(using Context): Type =
@@ -1570,19 +1570,18 @@ object Types extends TypeUtils {
       case tp: AppliedType => tp.underlyingNormalizable
       case _ => NoType
 
-    private def widenDealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = {
-      val res = this.widen.dealias1(keep, keepOpaques = false)
-      if (res eq this) res else res.widenDealias1(keep)
-    }
+    private def widenDealias(keeps: Keeps)(using Context): Type =
+      val tp1 = widen.dealias(keeps)
+      if tp1 eq this then this else tp1.widenDealias(keeps)
 
     /** Perform successive widenings and dealiasings until none can be applied anymore */
-    final def widenDealias(using Context): Type = widenDealias1(keepNever)
+    final def widenDealias(using Context): Type = widenDealias(KeepNothing)
 
     /** Perform successive widenings and dealiasings while rewrapping annotations, until none can be applied anymore */
-    final def widenDealiasKeepAnnots(using Context): Type = widenDealias1(keepAlways)
+    final def widenDealiasKeepAnnots(using Context): Type = widenDealias(KeepAnnots)
 
     /** Perform successive widenings and dealiasings while rewrapping refining annotations, until none can be applied anymore */
-    final def widenDealiasKeepRefiningAnnots(using Context): Type = widenDealias1(keepIfRefining)
+    final def widenDealiasKeepRefiningAnnots(using Context): Type = widenDealias(KeepRefiningAnnots)
 
     /** Widen from constant type to its underlying non-constant
      *  base type.
@@ -7101,6 +7100,16 @@ object Types extends TypeUtils {
     def isStable = true
   }
 
+  // ----- Dealias keep flags --------------------------------------------
+
+  private type Keeps = Int
+
+  private val KeepNothing = 0
+  private val KeepAnnots = 1
+  private val KeepRefiningAnnots = 2
+  private val KeepOpaques = 4
+  private val KeepTypeVars = 8
+
   // ----- Debug ---------------------------------------------------------
 
   @sharable var debugTrace: Boolean = false