Convert context functions in SymbolLoaders to CFTs

Author: odersky

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

@@ -46,9 +46,9 @@ object NamerOps:
   def adjustModuleCompleter(completer: LazyType, name: Name)(using Context): LazyType =
     val scope = ctx.effectiveScope
     if name.isTermName then
-      completer.withModuleClass(implicit ctx => findModuleBuddy(name.moduleClassName, scope))
+      completer.withModuleClass(findModuleBuddy(name.moduleClassName, scope))
     else
-      completer.withSourceModule(implicit ctx => findModuleBuddy(name.sourceModuleName, scope))
+      completer.withSourceModule(findModuleBuddy(name.sourceModuleName, scope))
 
   /** Find moduleClass/sourceModule in effective scope */
   private def findModuleBuddy(name: Name, scope: Scope)(using Context) = {

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

@@ -2431,27 +2431,29 @@ object SymDenotations {
     def apply(sym: Symbol): LazyType = this
     def apply(module: TermSymbol, modcls: ClassSymbol): LazyType = this
 
-    private val NoSymbolFn = (_: Context) => NoSymbol
     private var myDecls: Scope = EmptyScope
-    private var mySourceModuleFn: Context => Symbol = NoSymbolFn
-    private var myModuleClassFn: Context => Symbol = NoSymbolFn
+    private var mySourceModuleFn: Context ?=> Symbol = LazyType.NoSymbolFn
+    private var myModuleClassFn: Context ?=> Symbol = LazyType.NoSymbolFn
 
     /** The type parameters computed by the completer before completion has finished */
     def completerTypeParams(sym: Symbol)(using Context): List[TypeParamInfo] =
       if (sym.is(Touched)) Nil // return `Nil` instead of throwing a cyclic reference
       else sym.info.typeParams
 
     def decls: Scope = myDecls
-    def sourceModule(using Context): Symbol = mySourceModuleFn(ctx)
-    def moduleClass(using Context): Symbol = myModuleClassFn(ctx)
+    def sourceModule(using Context): Symbol = mySourceModuleFn
+    def moduleClass(using Context): Symbol = myModuleClassFn
 
     def withDecls(decls: Scope): this.type = { myDecls = decls; this }
-    def withSourceModule(sourceModuleFn: Context => Symbol): this.type = { mySourceModuleFn = sourceModuleFn; this }
-    def withModuleClass(moduleClassFn: Context => Symbol): this.type = { myModuleClassFn = moduleClassFn; this }
+    def withSourceModule(sourceModuleFn: Context ?=> Symbol): this.type = { mySourceModuleFn = sourceModuleFn; this }
+    def withModuleClass(moduleClassFn: Context ?=> Symbol): this.type = { myModuleClassFn = moduleClassFn; this }
 
     override def toString: String = getClass.toString
   }
 
+  object LazyType:
+    private val NoSymbolFn = (using _: Context) => NoSymbol
+
   /** A subtrait of LazyTypes where completerTypeParams yields a List[TypeSymbol], which
    *  should be completed independently of the info.
    */

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

@@ -57,7 +57,7 @@ object SymbolLoaders {
       modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
     val module = newModuleSymbol(
       owner, name.toTermName.decode, modFlags, clsFlags,
-      (module, _) => completer.proxy withDecls newScope withSourceModule (_ => module),
+      (module, _) => completer.proxy.withDecls(newScope).withSourceModule(module),
       assocFile = completer.sourceFileOrNull)
     enterNew(owner, module, completer, scope)
     enterNew(owner, module.moduleClass, completer, scope)
@@ -379,7 +379,7 @@ abstract class SymbolLoader extends LazyType { self =>
         else
           newModuleSymbol(
             rootDenot.owner, rootDenot.name.toTermName, Synthetic, Synthetic,
-            (module, _) => NoLoader().withDecls(newScope).withSourceModule(_ => module))
+            (module, _) => NoLoader().withDecls(newScope).withSourceModule(module))
             .moduleClass.denot.asClass
     }
     if (rootDenot.is(ModuleClass)) (linkedDenot, rootDenot)

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

@@ -76,7 +76,7 @@ class ClassfileParser(
   private var Scala2UnpicklingMode = Mode.Scala2Unpickling
 
   classRoot.info = NoLoader().withDecls(instanceScope)
-  moduleRoot.info = NoLoader().withDecls(staticScope).withSourceModule(_ => staticModule)
+  moduleRoot.info = NoLoader().withDecls(staticScope).withSourceModule(staticModule)
 
   private def currentIsTopLevel(using Context) = classRoot.owner.is(Flags.PackageClass)
 

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -524,7 +524,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           def completer(cls: Symbol) = {
             val unpickler = new ClassUnpickler(infoRef) withDecls symScope(cls)
             if (flags.is(ModuleClass))
-              unpickler withSourceModule (implicit ctx =>
+              unpickler.withSourceModule(
                 cls.owner.info.decls.lookup(cls.name.sourceModuleName)
                   .suchThat(_.is(Module)).symbol)
             else unpickler
@@ -538,7 +538,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           moduleRoot setFlag flags
           moduleRoot.symbol
         } else newSymbol(owner, name.asTermName, flags,
-          new LocalUnpickler() withModuleClass(implicit ctx =>
+          new LocalUnpickler().withModuleClass(
             owner.info.decls.lookup(name.moduleClassName)
               .suchThat(_.is(Module)).symbol)
           , privateWithin, coord = start)
@@ -642,7 +642,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int): ClassUnpickler =
     (new ClassUnpickler(infoRef) with SymbolLoaders.SecondCompleter {
       override def startCoord(denot: SymDenotation): Coord = start
-    }) withDecls symScope(cls) withSourceModule (_ => module)
+    }).withDecls(symScope(cls)).withSourceModule(module)
 
   /** Convert
    *    tp { type name = sym } forSome { sym >: L <: H }

docs/docs/contributing/debugging.md

@@ -363,4 +363,4 @@ trace.force(i"typing $tree", typr, show = true) { // ...
 ```
 
 ### Reporter
-Defined in [Reporter.scala](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/compiler/src/dotty/tools/dotc/reporting/Reporter.scala). Enables calls such as `ctx.log`, `ctx.error` etc. To enable, run dotc with `-Ylog:typer` option.
+Defined in [Reporter.scala](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/compiler/src/dotty/tools/dotc/reporting/Reporter.scala). Enables calls such as `report.log`. To enable, run dotc with `-Ylog:typer` option.