Drop ephemeral

Changing the interpolation scheme uncovered several cache invalidation problems with

 - the asSeenFrom cache in Denotations
 - the superType cache in AppliedType
 - the lastDenotation cache in NamedType

The new denotation scheme performed essentially same operations as the old one, but sometimes
in a different order. I am still not quite sure how the differences made the cache invalidations
fail. On the other hand, it is quite plausible (obvious even, in retrospect) that the previous
invalidation schemes are incomplete. So this commit replaces them with a common algorithm that
does not rely on the previous global state represented by `ephemeral`.

Author: odersky

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

@@ -130,7 +130,7 @@ object Denotations {
         if ((cachedPrefix ne pre) || ctx.period != validAsSeenFrom) {
           cachedAsSeenFrom = computeAsSeenFrom(pre)
           cachedPrefix = pre
-          validAsSeenFrom = ctx.period
+          validAsSeenFrom = if (pre.isProvisional) Nowhere else ctx.period
         }
         cachedAsSeenFrom
       } else computeAsSeenFrom(pre)

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

@@ -42,19 +42,6 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
   private val previousConstraint =
     if (previous == null) constraint else previous.constraint
 
-  private[this] var myEphemeral: Boolean =
-    if (previous == null) false else previous.ephemeral
-
-  /** The ephemeral flag is set as a side effect if an operation accesses
-   *  the underlying type of a type variable. The reason we need this flag is
-   *  that any such operation is not referentially transparent; it might logically change
-   *  its value at the moment the type variable is instantiated. Caching code needs to
-   *  check the ephemeral flag; If the flag is set during an operation, the result
-   *  of that operation should not be cached.
-   */
-  def ephemeral = myEphemeral
-  def ephemeral_=(x: Boolean): Unit = { myEphemeral = x }
-
   private[this] var myIsCommittable = true
 
   def isCommittable = myIsCommittable
@@ -159,7 +146,6 @@ class TyperState(previous: TyperState /* | Null */) extends DotClass with Showab
     constraint foreachTypeVar { tvar =>
       if (tvar.owningState.get eq this) tvar.owningState = new WeakReference(targetState)
     }
-    targetState.ephemeral |= ephemeral
     targetState.gc()
     reporter.flush()
     isCommitted = true

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

@@ -96,6 +96,41 @@ object Types {
       nextId
     }
 
+    /** A cache indicating whether the type was still provisional, last time we checked */
+    @sharable private var mightBeProvisional = true
+
+    /** Is this type still provisional? This is the case if the type contains, or depends on,
+     *  uninstantiated type variables or type symbols that have the Provisional flag set.
+     *  This is an antimonotonic property - once a type is not provisional, it stays so forever.
+     */
+    def isProvisional(implicit ctx: Context) = mightBeProvisional && testProvisional
+
+    private def testProvisional(implicit ctx: Context) = {
+      val accu = new TypeAccumulator[Boolean] {
+        override def apply(x: Boolean, t: Type) =
+          x || t.mightBeProvisional && {
+            t.mightBeProvisional = t match {
+              case t: TypeVar =>
+                !t.inst.exists
+              case t: TypeRef =>
+                (t: Type).mightBeProvisional = false // break cycles
+                t.symbol.is(Provisional) ||
+                apply(x, t.prefix) || {
+                  t.info match {
+                    case TypeAlias(alias) => apply(x, alias)
+                    case TypeBounds(lo, hi) => apply(apply(x, lo), hi)
+                    case _ => false
+                  }
+                }
+              case _ =>
+                foldOver(x, t)
+            }
+            t.mightBeProvisional
+          }
+      }
+      accu.apply(false, this)
+    }
+
     /** Is this type different from NoType? */
     def exists: Boolean = true
 
@@ -590,7 +625,6 @@ object Types {
         val next = tp.underlying
         ctx.typerState.constraint.entry(tp) match {
           case bounds: TypeBounds if bounds ne next =>
-            ctx.typerState.ephemeral = true
             go(bounds.hi)
           case _ =>
             go(next)
@@ -1667,9 +1701,7 @@ object Types {
     private def computeDenot(implicit ctx: Context): Denotation = {
 
       def finish(d: Denotation) = {
-        if (ctx.typerState.ephemeral)
-          record("ephemeral cache miss: memberDenot")
-        else if (d.exists)
+        if (d.exists)
           // Avoid storing NoDenotations in the cache - we will not be able to recover from
           // them. The situation might arise that a type has NoDenotation in some later
           // phase but a defined denotation earlier (e.g. a TypeRef to an abstract type
@@ -1696,23 +1728,19 @@ object Types {
             finish(symd.current)
       }
 
-      val savedEphemeral = ctx.typerState.ephemeral
-      ctx.typerState.ephemeral = false
-      try
-        lastDenotation match {
-          case lastd0: SingleDenotation =>
-            val lastd = lastd0.skipRemoved
-            if (lastd.validFor.runId == ctx.runId) finish(lastd.current)
-            else lastd match {
-              case lastd: SymDenotation =>
-                if (ctx.stillValid(lastd)) finish(lastd.current)
-                else finish(memberDenot(lastd.initial.name, allowPrivate = false))
-              case _ =>
-                fromDesignator
-            }
-          case _ => fromDesignator
-        }
-      finally ctx.typerState.ephemeral |= savedEphemeral
+      lastDenotation match {
+        case lastd0: SingleDenotation =>
+          val lastd = lastd0.skipRemoved
+          if (lastd.validFor.runId == ctx.runId) finish(lastd.current)
+          else lastd match {
+            case lastd: SymDenotation =>
+              if (ctx.stillValid(lastd)) finish(lastd.current)
+              else finish(memberDenot(lastd.initial.name, allowPrivate = false))
+            case _ =>
+              fromDesignator
+          }
+        case _ => fromDesignator
+      }
     }
 
     private def disambiguate(d: Denotation)(implicit ctx: Context): Denotation =
@@ -1797,7 +1825,7 @@ object Types {
 
       lastDenotation = denot
       lastSymbol = denot.symbol
-      checkedPeriod = ctx.period
+      checkedPeriod = if (prefix.isProvisional) Nowhere else ctx.period
       designator match {
         case sym: Symbol if designator ne lastSymbol =>
           designator = lastSymbol.asInstanceOf[Designator{ type ThisName = self.ThisName }]
@@ -3138,20 +3166,13 @@ object Types {
 
     override def superType(implicit ctx: Context): Type = {
       if (ctx.period != validSuper) {
-        validSuper = ctx.period
         cachedSuper = tycon match {
           case tycon: HKTypeLambda => defn.AnyType
-          case tycon: TypeVar if !tycon.inst.exists =>
-            // supertype not stable, since underlying might change
-            validSuper = Nowhere
-            tycon.underlying.applyIfParameterized(args)
-          case tycon: TypeRef if tycon.symbol.isClass =>
-            tycon
-          case tycon: TypeProxy =>
-            if (tycon.typeSymbol.is(Provisional)) validSuper = Nowhere
-            tycon.superType.applyIfParameterized(args)
+          case tycon: TypeRef if tycon.symbol.isClass => tycon
+          case tycon: TypeProxy => tycon.superType.applyIfParameterized(args)
           case _ => defn.AnyType
         }
+        validSuper = if (tycon.isProvisional) Nowhere else ctx.period
       }
       cachedSuper
     }
@@ -3360,10 +3381,7 @@ object Types {
      *  uninstantiated
      */
     def instanceOpt(implicit ctx: Context): Type =
-      if (inst.exists) inst else {
-        ctx.typerState.ephemeral = true
-        ctx.typerState.instType(this)
-      }
+      if (inst.exists) inst else ctx.typerState.instType(this)
 
     /** Is the variable already instantiated? */
     def isInstantiated(implicit ctx: Context) = instanceOpt.exists
@@ -3403,11 +3421,7 @@ object Types {
     /** If the variable is instantiated, its instance, otherwise its origin */
     override def underlying(implicit ctx: Context): Type = {
       val inst = instanceOpt
-      if (inst.exists) inst
-      else {
-        ctx.typerState.ephemeral = true
-        origin
-      }
+      if (inst.exists) inst else origin
     }
 
     override def computeHash(bs: Binders): Int = identityHash(bs)

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

@@ -224,14 +224,9 @@ object Implicits {
         }
         else if (ctx eq NoContext) Nil
         else {
-          val savedEphemeral = ctx.typerState.ephemeral
-          ctx.typerState.ephemeral = false
-          try {
-            val result = computeEligible(tp)
-            if (ctx.typerState.ephemeral) record("ephemeral cache miss: eligible")
-            else eligibleCache.put(tp, result)
-            result
-          } finally ctx.typerState.ephemeral |= savedEphemeral
+          val result = computeEligible(tp)
+          eligibleCache.put(tp, result)
+          result
         }
       }
     }
@@ -470,27 +465,20 @@ trait ImplicitRunInfo { self: Run =>
      *  @param isLifted    Type `tp` is the result of a `liftToClasses` application
      */
     def iscope(tp: Type, isLifted: Boolean = false): OfTypeImplicits = {
-      val canCache = Config.cacheImplicitScopes && tp.hash != NotCached
+      val canCache = Config.cacheImplicitScopes && tp.hash != NotCached && !tp.isProvisional
       def computeIScope() = {
-        val savedEphemeral = ctx.typerState.ephemeral
-        ctx.typerState.ephemeral = false
-        try {
-          val liftedTp = if (isLifted) tp else liftToClasses(tp)
-          val refs =
-            if (liftedTp ne tp)
-              iscope(liftedTp, isLifted = true).companionRefs
-            else
-              collectCompanions(tp)
-          val result = new OfTypeImplicits(tp, refs)(ctx)
-          if (ctx.typerState.ephemeral)
-            record("ephemeral cache miss: implicitScope")
-          else if (canCache &&
-                   ((tp eq rootTp) ||          // first type traversed is always cached
-                    !incomplete.contains(tp))) // other types are cached if they are not incomplete
-            implicitScopeCache(tp) = result
-          result
-        }
-        finally ctx.typerState.ephemeral |= savedEphemeral
+        val liftedTp = if (isLifted) tp else liftToClasses(tp)
+        val refs =
+          if (liftedTp ne tp)
+            iscope(liftedTp, isLifted = true).companionRefs
+          else
+            collectCompanions(tp)
+        val result = new OfTypeImplicits(tp, refs)(ctx)
+        if (canCache &&
+            ((tp eq rootTp) ||          // first type traversed is always cached
+             !incomplete.contains(tp))) // other types are cached if they are not incomplete
+          implicitScopeCache(tp) = result
+        result
       }
       if (canCache) implicitScopeCache.getOrElse(tp, computeIScope())
       else computeIScope()