Add new SymbolLoader: NoLoader

When a SymbolLoader gets completed, we sometimes use NoCompleter as an
intermediate info, we now use NoLoader instead. This will be useful in
the next commit where we restrict which completers are allowed to set
`isAbsent`. We must allow SymbolLoader to set `isAbsent` , but we don't
want to allow any NoCompleter to set it, so instead we use NoLoader
which is a subtype of both SymbolLoader and NoCompleter.

It also turns out that even without the changes to `isAbsent`, using a
`SymbolLoader` here is a good idea since `SymDenotation#isCurrent`
handles SymbolLoader specially and did not take into account that they
were sometimes replaced by NoCompleter. This means that checking for the
presence of a flag can now lead to more completion, which required
adding an early exit in `Types#isArgPrefixOf` to avoid a cyclic
reference.

Author: smarter

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

@@ -2180,11 +2180,11 @@ object SymDenotations {
   }
 
   /** A missing completer */
-  @sharable class NoCompleter extends LazyType {
+  trait NoCompleter extends LazyType {
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit = unsupported("complete")
   }
 
-  object NoCompleter extends NoCompleter
+  @sharable object NoCompleter extends NoCompleter
 
   /** A lazy type for modules that points to the module class.
    *  Needed so that `moduleClass` works before completion.

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

@@ -375,7 +375,7 @@ abstract class SymbolLoader extends LazyType { self =>
         else
           ctx.newModuleSymbol(
             rootDenot.owner, rootDenot.name.toTermName, Synthetic, Synthetic,
-            (module, _) => new NoCompleter() withDecls newScope withSourceModule (_ => module))
+            (module, _) => NoLoader().withDecls(newScope).withSourceModule(_ => module))
             .moduleClass.denot.asClass
     }
     if (rootDenot.is(ModuleClass)) (linkedDenot, rootDenot)
@@ -416,3 +416,13 @@ class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
   def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
     ctx.run.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
 }
+
+/** A NoCompleter which is also a SymbolLoader. */
+class NoLoader extends SymbolLoader with NoCompleter {
+  def description(implicit ctx: Context): String = "NoLoader"
+  override def sourceFileOrNull: AbstractFile = null
+  override def complete(root: SymDenotation)(implicit ctx: Context): Unit =
+    super[NoCompleter].complete(root)
+  def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
+    unsupported("doComplete")
+}

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

@@ -235,6 +235,7 @@ object Types {
      *  from the ThisType of `symd`'s owner.
      */
     def isArgPrefixOf(symd: SymDenotation)(implicit ctx: Context): Boolean =
+      symd.exists && !symd.owner.is(Package) && // Early exit if possible because the next check would force SymbolLoaders
       symd.isAllOf(ClassTypeParam) && {
         this match {
           case tp: ThisType => tp.cls ne symd.owner

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -72,8 +72,8 @@ class ClassfileParser(
 
   private[this] var Scala2UnpicklingMode = Mode.Scala2Unpickling
 
-  classRoot.info = (new NoCompleter).withDecls(instanceScope)
-  moduleRoot.info = (new NoCompleter).withDecls(staticScope).withSourceModule(_ => staticModule)
+  classRoot.info = NoLoader().withDecls(instanceScope)
+  moduleRoot.info = NoLoader().withDecls(staticScope).withSourceModule(_ => staticModule)
 
   private def currentIsTopLevel(implicit ctx: Context) = classRoot.owner.is(Flags.PackageClass)