Move deskolemization from TypeComparer to TypeOps

It's no longer needed in TypeComparer. We now deskolemize when locally inferring types of vals and defs.

1 files changed, 97 insertions, 0 deletions

diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala
index c4673d569..fb641f247 100644
--- a/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/src/dotty/tools/dotc/core/TypeOps.scala
@@ -76,6 +76,103 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     var unstable = false
   }
 
+ /** Approximate a type `tp` with a type that does not contain skolem types.
+   */
+  final def deskolemize(tp: Type): Type = deskolemize(tp, 1, Set())
+
+  private def deskolemize(tp: Type, variance: Int, seen: Set[SkolemType]): Type = {
+    def approx(lo: Type = defn.NothingType, hi: Type = defn.AnyType, newSeen: Set[SkolemType] = seen) =
+      if (variance == 0) NoType
+      else deskolemize(if (variance < 0) lo else hi, variance, newSeen)
+    tp match {
+      case tp: SkolemType =>
+        if (seen contains tp) NoType
+        else approx(hi = tp.info, newSeen = seen + tp)
+      case tp: NamedType =>
+        val sym = tp.symbol
+        if (sym.isStatic) tp
+        else {
+          val pre1 = deskolemize(tp.prefix, variance, seen)
+          if (pre1 eq tp.prefix) tp
+          else {
+            val d = tp.prefix.member(tp.name)
+            d.info match {
+              case TypeAlias(alias) => deskolemize(alias, variance, seen)
+              case _ =>
+                if (pre1.exists && !pre1.isRef(defn.NothingClass)) tp.derivedSelect(pre1)
+                else {
+                  ctx.log(s"deskolem: $tp: ${tp.info}")
+                  tp.info match {
+                    case TypeBounds(lo, hi) => approx(lo, hi)
+                    case info => approx(defn.NothingType, info)
+                  }
+                }
+            }
+          }
+        }
+      case _: ThisType | _: BoundType | _: SuperType | NoType | NoPrefix =>
+        tp
+      case tp: RefinedType =>
+        val parent1 = deskolemize(tp.parent, variance, seen)
+        if (parent1.exists) {
+          val refinedInfo1 = deskolemize(tp.refinedInfo, variance, seen)
+          if (refinedInfo1.exists)
+            tp.derivedRefinedType(parent1, tp.refinedName, refinedInfo1)
+          else
+            approx(hi = parent1)
+        }
+        else approx()
+      case tp: TypeAlias =>
+        val alias1 = deskolemize(tp.alias, variance * tp.variance, seen)
+        if (alias1.exists) tp.derivedTypeAlias(alias1)
+        else approx(hi = TypeBounds.empty)
+      case tp: TypeBounds =>
+        val lo1 = deskolemize(tp.lo, -variance, seen)
+        val hi1 = deskolemize(tp.hi, variance, seen)
+        if (lo1.exists && hi1.exists) tp.derivedTypeBounds(lo1, hi1)
+        else approx(hi =
+          if (lo1.exists) TypeBounds.lower(lo1)
+          else if (hi1.exists) TypeBounds.upper(hi1)
+          else TypeBounds.empty)
+      case tp: ClassInfo =>
+        val pre1 = deskolemize(tp.prefix, variance, seen)
+        if (pre1.exists) tp.derivedClassInfo(pre1)
+        else NoType
+      case tp: AndOrType =>
+        val tp1d = deskolemize(tp.tp1, variance, seen)
+        val tp2d = deskolemize(tp.tp2, variance, seen)
+        if (tp1d.exists && tp2d.exists)
+          tp.derivedAndOrType(tp1d, tp2d)
+        else if (tp.isAnd)
+          approx(hi = tp1d & tp2d)  // if one of tp1d, tp2d exists, it is the result of tp1d & tp2d
+        else
+          approx(lo = tp1d & tp2d)
+      case tp: WildcardType =>
+        val bounds1 = deskolemize(tp.optBounds, variance, seen)
+        if (bounds1.exists) tp.derivedWildcardType(bounds1)
+        else WildcardType
+      case _ =>
+        if (tp.isInstanceOf[MethodicType]) assert(variance != 0, tp)
+        deskolemizeMap.mapOver(tp, variance, seen)
+    }
+  }
+
+  object deskolemizeMap extends TypeMap {
+    private var seen: Set[SkolemType] = _
+    def apply(tp: Type) = deskolemize(tp, variance, seen)
+    def mapOver(tp: Type, variance: Int, seen: Set[SkolemType]) = {
+      val savedVariance = this.variance
+      val savedSeen = this.seen
+      this.variance = variance
+      this.seen = seen
+      try super.mapOver(tp)
+      finally {
+        this.variance = savedVariance
+        this.seen = savedSeen
+      }
+    }
+  }
+
   /** Implementation of Types#simplified */
   final def simplify(tp: Type, theMap: SimplifyMap): Type = tp match {
     case tp: NamedType =>