Renamings

module => sourceModule in class ClassCompleter
LazyModuleInfo => ModuleCompleter

4 files changed, 14 insertions, 14 deletions

diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index c6d90737d..c019d94e0 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -422,7 +422,7 @@ object SymDenotations {
     /** The class implementing this module, NoSymbol if not applicable. */
     final def moduleClass: Symbol = _info match {
       case info: TypeRefBySym if this is ModuleVal => info.fixedSym
-      case info: LazyModuleInfo => info.mclass
+      case info: ModuleCompleter => info.mclass
       case _ => NoSymbol
     }
 
@@ -431,7 +431,7 @@ object SymDenotations {
       case ClassInfo(_, _, _, _, selfType: TermRefBySym) if this is ModuleClass =>
         selfType.fixedSym
       case info: ClassCompleter =>
-        info.module
+        info.sourceModule
       case _ =>
         NoSymbol
     }
@@ -982,12 +982,12 @@ object SymDenotations {
   class ClassCompleter(val decls: Scope, underlying: LazyType = NoCompleter)
       extends LazyType {
     def complete(denot: SymDenotation): Unit = underlying.complete(denot)
-    def module: Symbol = NoSymbol
+    def sourceModule: Symbol = NoSymbol
   }
 
-  class ModuleClassCompleter(modul: Symbol, underlying: LazyType = NoCompleter)
+  class ModuleClassCompleter(module: Symbol, underlying: LazyType = NoCompleter)
     extends ClassCompleter(newScope, underlying) {
-      override def module = modul
+      override def sourceModule = module
     }
 
   object NoCompleter extends LazyType {
@@ -999,7 +999,7 @@ object SymDenotations {
    *  Completion of modules is always completion of the underlying
    *  module class, followed by copying the relevant fields to the module.
    */
-  class LazyModuleInfo(val mclass: ClassSymbol)(implicit cctx: CondensedContext) extends LazyType {
+  class ModuleCompleter(val mclass: ClassSymbol)(implicit cctx: CondensedContext) extends LazyType {
     def complete(denot: SymDenotation): Unit = {
       val from = denot.moduleClass.denot.asClass
       denot.setFlag(from.flags.toTermFlags & RetainedModuleValFlags)
diff --git a/src/dotty/tools/dotc/core/SymbolLoaders.scala b/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 387ca4afd..ad3b63fe8 100644
--- a/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -141,16 +141,16 @@ class SymbolLoaders {
 
   /** Load contents of a package
    */
-  class PackageLoader(override val module: TermSymbol, classpath: ClassPath)(implicit val cctx: CondensedContext)
+  class PackageLoader(override val sourceModule: TermSymbol, classpath: ClassPath)(implicit val cctx: CondensedContext)
       extends ClassCompleter(newScope) with SymbolLoader {
     def description = "package loader " + classpath.name
 
     def doComplete(root: SymDenotation) {
       assert(root is PackageClass, root)
       val pre = root.owner.thisType
-      root.info = ClassInfo(pre, root.symbol.asClass, Nil, root.preCompleteDecls, TermRef(pre, module))
-      if (!module.isCompleted)
-        module.completer.complete(module)
+      root.info = ClassInfo(pre, root.symbol.asClass, Nil, root.preCompleteDecls, TermRef(pre, sourceModule))
+      if (!sourceModule.isCompleted)
+        sourceModule.completer.complete(sourceModule)
       if (!root.isRoot) {
         for (classRep <- classpath.classes) {
           initializeFromClassPath(root.symbol, classRep)
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index ee53b0368..12c3c7beb 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -124,7 +124,7 @@ trait Symbols { this: Context =>
     val mdenot = SymDenotation(
         module, owner, name, modFlags | ModuleCreationFlags,
         if (cdenot.isCompleted) TypeRef(owner.thisType, name.toTypeName, modcls)
-        else new LazyModuleInfo(modcls)(condensed))
+        else new ModuleCompleter(modcls)(condensed))
     module.denot = mdenot
     modcls.denot = cdenot
     module
diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
index 92a44aaa1..d320ec280 100644
--- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
@@ -459,7 +459,7 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
           cctx.newSymbol(owner, name, flags, localMemberUnpickler, coord = start)
         else {
           def completer(cls: Symbol) = new LocalClassUnpickler(cls) {
-            override def module =
+            override def sourceModule =
               if (flags is ModuleClass)
                 cls.owner.preCompleteDecls.lookup(
                   cls.name.stripModuleClassSuffix.toTermName).suchThat(_ is Module).symbol
@@ -533,9 +533,9 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
 
   class LocalClassUnpickler(cls: Symbol) extends ClassCompleter(symScope(cls), localMemberUnpickler)
 
-  def rootClassUnpickler(start: Coord, cls: Symbol, modul: Symbol) =
+  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol) =
     new ClassCompleter(symScope(cls), new AtStartUnpickler(start)) with SymbolLoaders.SecondCompleter {
-      override def module = modul
+      override def sourceModule = module
     }
 
   /** Convert