Mad baseType more context dependent

Roll the functionality of contextualBaseType into baseType itself.

Author: odersky

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

@@ -1636,15 +1636,16 @@ object SymDenotations {
        *    cache ErasedValueType at all.
        */
       def isCachable(tp: Type, btrCache: BaseTypeMap): Boolean = {
-        def inCache(tp: Type) = btrCache.containsKey(tp)
+        def inCache(tp: Type) = btrCache.containsKey(tp) && isCachable(tp, btrCache)
         tp match {
-          case _: TypeErasure.ErasedValueType => false
           case tp: TypeRef if tp.symbol.isClass => true
           case tp: TypeVar => tp.inst.exists && inCache(tp.inst)
+          case tp: TypeParamRef if ctx.typerState.constraint.contains(tp) => false
           //case tp: TypeProxy => inCache(tp.underlying) // disabled, can re-enable insyead of last two lines for performance testing
           case tp: TypeProxy => isCachable(tp.underlying, btrCache)
           case tp: AndType => isCachable(tp.tp1, btrCache) && isCachable(tp.tp2, btrCache)
           case tp: OrType  => isCachable(tp.tp1, btrCache) && isCachable(tp.tp2, btrCache)
+          case _: TypeErasure.ErasedValueType => false
           case _ => true
         }
       }
@@ -1685,6 +1686,8 @@ object SymDenotations {
               case tparams: List[Symbol @unchecked] =>
                 baseTypeOf(tycon).subst(tparams, args)
             }
+          case tp: TypeParamRef =>
+            baseTypeOf(ctx.typeComparer.bounds(tp).hi)
           case tp: TypeProxy =>
             baseTypeOf(tp.superType)
           case AndType(tp1, tp2) =>
@@ -1709,19 +1712,24 @@ object SymDenotations {
         tp.stripTypeVar match {
           case tp: CachedType =>
           val btrCache = baseTypeCache
+          if (!isCachable(tp, btrCache))
+            computeBaseTypeOf(tp)
+          else
             try {
-              var basetp = btrCache get tp
+              var basetp = btrCache.get(tp)
               if (basetp == null) {
                 btrCache.put(tp, NoPrefix)
                 basetp = computeBaseTypeOf(tp)
-                if (!basetp.exists) Stats.record("base type miss")
-                if (isCachable(tp, btrCache)) {
-                  if (basetp.exists) Stats.record("cached base type hit")
-                  else Stats.record("cached base type miss")
+                if (basetp.exists) {
+                  Stats.record("cached base type exists")
                   btrCache.put(tp, basetp)
                 }
-                else btrCache.remove(tp)
-              } else if (basetp `eq` NoPrefix)
+                else {
+                  Stats.record("cached base type missing")
+                  btrCache.remove(tp)
+                }
+              }
+              else if (basetp `eq` NoPrefix)
                 throw CyclicReference(this)
               basetp
             }

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

@@ -863,30 +863,6 @@ object Types {
       }
     }
 
-    /** Like basetype, but follow context bounds */
-    final def contextualBaseType(cls: ClassSymbol)(implicit ctx: Context): Type = {
-      def loop(tp: Type): Type = tp match {
-        case tp: TypeRef =>
-          val sym = tp.symbol
-          if (sym.isClass) tp.baseType(cls) else loop(tp.superType): @tailrec
-        case tp: AppliedType =>
-          tp.baseType(cls)
-        case tp: TypeParamRef =>
-          loop(ctx.typeComparer.bounds(tp).hi): @tailrec
-        case tp: TypeProxy =>
-          loop(tp.superType): @tailrec
-        case tp: AndType =>
-          loop(tp.tp1) & loop(tp.tp2): @tailrec
-        case tp: OrType =>
-          loop(tp.tp1) | loop(tp.tp2): @tailrec
-        case tp: JavaArrayType =>
-          if (cls == defn.ObjectClass) cls.typeRef else NoType
-        case _ =>
-          NoType
-      }
-      loop(this)
-    }
-
     def & (that: Type)(implicit ctx: Context): Type = track("&") {
       ctx.typeComparer.glb(this, that)
     }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -652,7 +652,7 @@ trait Implicits { self: Typer =>
           arg
       case fail @ SearchFailure(failed) =>
         def trySpecialCase(cls: ClassSymbol, handler: Type => Tree, ifNot: => Tree) = {
-          val base = formalValue.contextualBaseType(cls)
+          val base = formalValue.baseType(cls)
           if (base <:< formalValue) {
             // With the subtype test we enforce that the searched type `formalValue` is of the right form
             handler(base).orElse(ifNot)