Introduce conditionally mutable flags wrt completion

Some flags do not fall under the definition of the
flags that are not mutated during completion. However,
in practice, they are almost never mutated on completion
and such an event is easy to predict. An example of such
a flag is `deferred` which is set only when compiling
opaque types – this is part of what makes opaque types work.
It is reasonable, hence, to make sure denotations are counted
as current even though they have some of such flags if
when querying these flags we can predict that they will not
change during completion.

Author: anatoliykmetyuk

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

@@ -436,7 +436,7 @@ object Flags {
   /** Flags that are not (re)set when completing the denotation
    */
   val FromStartFlags: FlagSet = commonFlags(
-    Module, Package, Deferred, Method, Case,
+    Module, Package, Method, Case,
     HigherKinded, Param, ParamAccessor,
     Scala2ExistentialCommon, Mutable, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
@@ -451,6 +451,21 @@ object Flags {
   val AfterLoadFlags: FlagSet = commonFlags(
     FromStartFlags, AccessFlags, Final, AccessorOrSealed, LazyOrTrait, SelfName, JavaDefined)
 
+  /** Flags that are not mutated during completion when a certain
+   *  condition is satisfied
+   */
+  object ConditionallyImmutableFlags {
+    val flagsAndConditions: List[(Flag, (given Contexts.Context) => SymDenotations.SymDenotation => Boolean)] = List(
+      Deferred -> { denot =>
+        denot.is(Opaque) && denot.isType &&
+        !denot.infoOrCompleter.isInstanceOf[SymbolLoader] // If it is loaded, we assume the opaque mechanism has already set the flags correctly
+      }
+    )
+
+    val flags: FlagSet = flagsAndConditions.map(_._1)
+      .foldLeft(EmptyFlags) { (accum, next) => accum | next }
+  }
+
 
   /** A value that's unstable unless complemented with a Stable flag */
   val UnstableValueFlags: FlagSet = Mutable | Method

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

@@ -201,10 +201,19 @@ object SymDenotations {
         if (myFlags.is(Trait)) NoInitsInterface & bodyFlags // no parents are initialized from a trait
         else NoInits & bodyFlags & parentFlags)
 
-    private def isCurrent(fs: FlagSet) =
-      fs <= (
+    private def isCurrent(fs: FlagSet)(implicit ctx: Context): Boolean =
+      val immutableFlags =
         if (myInfo.isInstanceOf[SymbolLoader]) FromStartFlags
-        else AfterLoadFlags)
+        else AfterLoadFlags
+      val mutableFlagsBeingQueried = fs &~ immutableFlags
+
+      mutableFlagsBeingQueried.isEmpty || ( // All flags are immutable wrt completion
+        mutableFlagsBeingQueried <= ConditionallyImmutableFlags.flags && // All the mutable flags being queried are not mutated during completion under certain conditions
+        ConditionallyImmutableFlags.flagsAndConditions.forall { case (flag, condition) =>
+          (flag & mutableFlagsBeingQueried).isEmpty || !condition(this)
+        }
+      )
+
 
     final def relevantFlagsFor(fs: FlagSet)(implicit ctx: Context) =
       if (isCurrent(fs)) myFlags else flags