Rename isAbsent to unforcedIsAbsent, add real isAbsent

Author: smarter

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

@@ -441,10 +441,17 @@ object SymDenotations {
     final def markAbsent(): Unit =
       myInfo = NoType
 
+    /** Is symbol known to not exist, or potentially not completed yet? */
+    final def unforcedIsAbsent(implicit ctx: Context): Boolean =
+      myInfo == NoType ||
+      (this is (ModuleVal, butNot = Package)) && moduleClass.unforcedIsAbsent
+
     /** Is symbol known to not exist? */
-    final def isAbsent(implicit ctx: Context): Boolean =
+    final def isAbsent(implicit ctx: Context): Boolean = {
+      ensureCompleted()
       myInfo == NoType ||
       (this is (ModuleVal, butNot = Package)) && moduleClass.isAbsent
+    }
 
     /** Is this symbol the root class or its companion object? */
     final def isRoot: Boolean =
@@ -563,7 +570,7 @@ object SymDenotations {
     final def isCoDefinedWith(that: Symbol)(implicit ctx: Context) =
       (this.effectiveOwner == that.effectiveOwner) &&
       (  !(this.effectiveOwner is PackageClass)
-        || this.isAbsent || that.isAbsent
+        || this.unforcedIsAbsent || that.unforcedIsAbsent
         || { // check if they are defined in the same file(or a jar)
            val thisFile = this.symbol.associatedFile
            val thatFile = that.symbol.associatedFile

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

@@ -185,7 +185,7 @@ trait Symbols { this: Context =>
   val companionMethodFlags = Flags.Synthetic | Flags.Private | Flags.Method
 
   def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context) =
-    if (owner.exists && target.exists && !owner.isAbsent && !target.isAbsent) {
+    if (owner.exists && target.exists && !owner.unforcedIsAbsent && !target.unforcedIsAbsent) {
       val existing = owner.unforcedDecls.lookup(name)
 
       existing.orElse{

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -33,7 +33,7 @@ class Pickler extends Phase {
   /** Drop any elements of this list that are linked module classes of other elements in the list */
   private def dropCompanionModuleClasses(clss: List[ClassSymbol])(implicit ctx: Context): List[ClassSymbol] = {
     val companionModuleClasses =
-      clss.filterNot(_ is Module).map(_.linkedClass).filterNot(_.isAbsent)
+      clss.filterNot(_ is Module).map(_.linkedClass).filterNot(_.unforcedIsAbsent)
     clss.filterNot(companionModuleClasses.contains)
   }
 

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

@@ -145,10 +145,7 @@ trait TypeAssigner {
   final def reallyExists(denot: Denotation)(implicit ctx: Context): Boolean = try
     denot match {
       case denot: SymDenotation =>
-        denot.exists && {
-          denot.ensureCompleted()
-          !denot.isAbsent
-        }
+        denot.exists && !denot.isAbsent
       case denot: SingleDenotation =>
         val sym = denot.symbol
         (sym eq NoSymbol) || reallyExists(sym.denot)