Process Deferred flag last on unpickling

Now that Deferred is conditionally immutable,
if we query it along with other properly immutable flags,
the query may trigger completion. This will happen if the
symbol in question is also opaque and is a type.

The completion will be rightfully triggered since
the opaque mechanism does indeed mutate the
deferred flag on opaque types. However, if e.g.
we query `is(Method, butNot = Deferred)` on
`opaque type B`, we may be able to return `false`
on the query as soon as we see that the symbol in
question is not a method, without triggering the completion.

Too early completion is undesirable since completion of
opaque types modifies the self-type of its owner.
If the completion of an opaque type happens during unpickling
of the owner itself, the self-type of the owner may be
rewritten later in its completion.

Author: anatoliykmetyuk

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

@@ -456,10 +456,7 @@ object Flags {
    */
   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
-      }
+      Deferred -> { denot => denot.is(Opaque) && denot.isType }
     )
 
     val flags: FlagSet = flagsAndConditions.map(_._1)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -677,7 +677,7 @@ class TreeUnpickler(reader: TastyReader,
             if (sym.isTerm && !sym.isOneOf(DeferredOrLazyOrMethod))
               initsFlags = EmptyFlags
             else if (sym.isClass ||
-              sym.is(Method, butNot = Deferred) && !sym.isConstructor)
+              sym.is(Method) && !sym.is(Deferred) && !sym.isConstructor)
               initsFlags &= NoInits
           case IMPORT =>
             skipTree()