Dissolve NamerContxtOps

Move operations to ContextOps (extension methods) and NamerOps (normal methods)

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -4,7 +4,7 @@ package ast
 
 import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import Symbols._, StdNames._, Trees._, Phases._
+import Symbols._, StdNames._, Trees._, Phases._, ContextOps._
 import Decorators.{given _}, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
 import typer.{FrontEnd, Namer}

compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala

@@ -2,6 +2,7 @@ package dotty.tools.dotc.ast
 
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.ContextOps.enter
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.TypeError
@@ -72,7 +73,8 @@ class TreeMapWithImplicits extends tpd.TreeMap {
     new TreeTraverser {
       def traverse(tree: Tree)(using Context): Unit = {
         tree match {
-          case d: DefTree if d.symbol.isOneOf(GivenOrImplicit) => nestedCtx.enter(d.symbol)
+          case d: DefTree if d.symbol.isOneOf(GivenOrImplicit) =>
+            nestedCtx.enter(d.symbol)
           case _ =>
         }
         traverseChildren(tree)

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

@@ -0,0 +1,75 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps._
+import Denotations._
+import SymDenotations.LazyType, Names.Name, StdNames.nme
+import ast.untpd
+
+/** Operations that are shared between Namer nand TreeUnpickler */
+object ContextOps:
+
+  extension (ctx: Context):
+
+    /** Enter symbol into current class, if current class is owner of current context,
+    *  or into current scope, if not. Should always be called instead of scope.enter
+    *  in order to make sure that updates to class members are reflected in
+    *  finger prints.
+    */
+    def enter(sym: Symbol): Symbol = inContext(ctx) {
+      ctx.owner match
+        case cls: ClassSymbol => cls.classDenot.enter(sym)
+        case _ => scope.openForMutations.enter(sym)
+      sym
+    }
+
+    /** The denotation with the given `name` and all `required` flags in current context
+     */
+    def denotNamed(name: Name, required: FlagSet = EmptyFlags): Denotation = inContext(ctx) {
+      if (owner.isClass)
+        if (outer.owner == owner) { // inner class scope; check whether we are referring to self
+          if (scope.size == 1) {
+            val elem = scope.lastEntry
+            if (elem.name == name) return elem.sym.denot // return self
+          }
+          val pre = owner.thisType
+          pre.findMember(name, pre, required, EmptyFlags)
+        }
+        else // we are in the outermost context belonging to a class; self is invisible here. See inClassContext.
+          owner.findMember(name, owner.thisType, required, EmptyFlags)
+      else
+        scope.denotsNamed(name).filterWithFlags(required, EmptyFlags).toDenot(NoPrefix)
+    }
+
+    /** A fresh local context with given tree and owner.
+    *  Owner might not exist (can happen for self valdefs), in which case
+    *  no owner is set in result context
+    */
+    def localContext(tree: untpd.Tree, owner: Symbol): FreshContext = inContext(ctx) {
+      val freshCtx = fresh.setTree(tree)
+      if (owner.exists) freshCtx.setOwner(owner) else freshCtx
+    }
+
+    /** Context where `sym` is defined, assuming we are in a nested context. */
+    def defContext(sym: Symbol): Context = inContext(ctx) {
+      outersIterator
+        .dropWhile(_.owner != sym)
+        .dropWhile(_.owner == sym)
+        .next()
+    }
+
+    /** A new context for the interior of a class */
+    def inClassContext(selfInfo: TypeOrSymbol): Context = inContext(ctx) {
+      val localCtx: Context = fresh.setNewScope
+      selfInfo match {
+        case sym: Symbol if sym.exists && sym.name != nme.WILDCARD => localCtx.scope.openForMutations.enter(sym)
+        case _ =>
+      }
+      localCtx
+    }
+
+    def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context = inContext(ctx) {
+      if (pkg.is(Package)) fresh.setOwner(pkg.moduleClass).setTree(tree)
+      else ctx
+    }
+end ContextOps

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

@@ -15,7 +15,7 @@ import ast.Trees._
 import ast.untpd
 import Flags.GivenOrImplicit
 import util.{NoSource, SimpleIdentityMap, SourceFile}
-import typer.{Implicits, ImportInfo, Inliner, NamerContextOps, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
+import typer.{Implicits, ImportInfo, Inliner, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
 import Nullables.{NotNullInfo, given _}
 import Implicits.ContextualImplicits
 import config.Settings._
@@ -98,8 +98,7 @@ object Contexts {
     extends Periods
        with Phases
        with Printers
-       with Reporting
-       with NamerContextOps { thiscontext =>
+       with Reporting { thiscontext =>
 
     given Context = this
 
@@ -252,6 +251,13 @@ object Contexts {
       implicitsCache
     }
 
+    /** Either the current scope, or, if the current context owner is a class,
+     *  the declarations of the current class.
+     */
+    def effectiveScope(using Context): Scope =
+      if owner != null && owner.isClass then owner.asClass.unforcedDecls
+      else scope
+
     /** Sourcefile corresponding to given abstract file, memoized */
     def getSource(file: AbstractFile, codec: => Codec = Codec(settings.encoding.value)) = {
       util.Stats.record("getSource")
@@ -507,6 +513,11 @@ object Contexts {
         case None => fresh.dropProperty(key)
       }
 
+    def typer: Typer = this.typeAssigner match {
+      case typer: Typer => typer
+      case _ => new Typer
+    }
+
     override def toString: String = {
       def iinfo(using Context) = if (ctx.importInfo == null) "" else i"${ctx.importInfo.selectors}%, %"
       "Context(\n" +

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

@@ -0,0 +1,60 @@
+package dotty.tools.dotc
+package core
+
+import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps._
+import Denotations._
+import SymDenotations.LazyType, Names.Name, StdNames.nme
+
+/** Operations that are shared between Namer nand TreeUnpickler */
+object NamerOps:
+
+  /** The given type, unless `sym` is a constructor, in which case the
+   *  type of the constructed instance is returned
+   */
+  def effectiveResultType(sym: Symbol, typeParams: List[Symbol], givenTp: Type)(using Context): Type =
+    if (sym.name == nme.CONSTRUCTOR) sym.owner.typeRef.appliedTo(typeParams.map(_.typeRef))
+    else givenTp
+
+  /** if isConstructor, make sure it has one non-implicit parameter list */
+  def normalizeIfConstructor(termParamss: List[List[Symbol]], isConstructor: Boolean)(using Context): List[List[Symbol]] =
+    if (isConstructor &&
+      (termParamss.isEmpty || termParamss.head.nonEmpty && termParamss.head.head.isOneOf(GivenOrImplicit)))
+      Nil :: termParamss
+    else
+      termParamss
+
+  /** The method type corresponding to given parameters and result type */
+  def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(using Context): Type =
+    val monotpe =
+      valueParamss.foldRight(resultType) { (params, resultType) =>
+        val (isContextual, isImplicit, isErased) =
+          if params.isEmpty then (false, false, false)
+          else (params.head.is(Given), params.head.is(Implicit), params.head.is(Erased))
+        val make = MethodType.companion(isJava = isJava, isContextual = isContextual, isImplicit = isImplicit, isErased = isErased)
+        if isJava then
+          for param <- params do
+            if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType
+        make.fromSymbols(params, resultType)
+      }
+    if typeParams.nonEmpty then PolyType.fromParams(typeParams.asInstanceOf[List[TypeSymbol]], monotpe)
+    else if valueParamss.isEmpty then ExprType(monotpe)
+    else monotpe
+
+  /** Add moduleClass or sourceModule functionality to completer
+   *  for a module or module class
+   */
+  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))
+    else
+      completer.withSourceModule(implicit ctx => findModuleBuddy(name.sourceModuleName, scope))
+
+  /** Find moduleClass/sourceModule in effective scope */
+  private def findModuleBuddy(name: Name, scope: Scope)(using Context) = {
+    val it = scope.lookupAll(name).filter(_.is(Module))
+    if (it.hasNext) it.next()
+    else NoSymbol.assertingErrorsReported(s"no companion $name in $scope")
+  }
+
+end NamerOps

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

@@ -18,6 +18,8 @@ import Flags._
 import Constants._
 import Annotations._
 import NameKinds._
+import NamerOps._
+import ContextOps._
 import Variances.Invariant
 import typer.ConstFold
 import typer.Checking.checkNonCyclic
@@ -559,7 +561,7 @@ class TreeUnpickler(reader: TastyReader,
       pickling.println(i"creating symbol $name at $start with flags $givenFlags")
       val flags = normalizeFlags(tag, givenFlags, name, isAbsType, rhsIsEmpty)
       def adjustIfModule(completer: LazyType) =
-        if (flags.is(Module)) ctx.adjustModuleCompleter(completer, name) else completer
+        if (flags.is(Module)) adjustModuleCompleter(completer, name) else completer
       val coord = coordAt(start)
       val sym =
         roots.find(root => (root.owner eq ctx.owner) && root.name == name) match {
@@ -815,10 +817,10 @@ class TreeUnpickler(reader: TastyReader,
           val vparamss = readParamss(using localCtx)
           val tpt = readTpt()(using localCtx)
           val typeParams = tparams.map(_.symbol)
-          val valueParamss = ctx.normalizeIfConstructor(
+          val valueParamss = normalizeIfConstructor(
               vparamss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
-          val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
-          sym.info = ctx.methodType(typeParams, valueParamss, resType)
+          val resType = effectiveResultType(sym, typeParams, tpt.tpe)
+          sym.info = methodType(typeParams, valueParamss, resType)
           DefDef(tparams, vparamss, tpt)
         case VALDEF =>
           val tpt = readTpt()(using localCtx)

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -6,7 +6,8 @@ import scala.annotation.tailrec
 import scala.collection._
 
 import ast.{NavigateAST, Trees, tpd, untpd}
-import core._, core.Decorators._
+import core._
+import Decorators._, ContextOps._
 import Contexts._, Flags._, Names._, NameOps._, Symbols._, Trees._, Types._
 import transform.SymUtils.decorateSymbol
 import util.Spans._, util.SourceFile, util.SourcePosition

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

@@ -2,6 +2,7 @@ package dotty.tools.dotc.transform
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.{Context, ctx}
+import dotty.tools.dotc.core.ContextOps._
 import dotty.tools.dotc.typer.Docstrings
 
 class CookComments extends MegaPhase.MiniPhase {

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

@@ -19,6 +19,7 @@ import Trees._
 import Names._
 import StdNames._
 import NameOps._
+import ContextOps._
 import NameKinds.DefaultGetterName
 import ProtoTypes._
 import Inferencing._

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

@@ -7,7 +7,7 @@ import ast._
 import ast.Trees._
 import StdNames._
 import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._, Decorators._
-import ProtoTypes._
+import ProtoTypes._, ContextOps._
 import util.Spans._
 import util.SourcePosition
 import collection.mutable
@@ -272,8 +272,8 @@ trait Deriving {
         (tparamRefs: List[Type]) => (paramRefss: List[List[tpd.Tree]]) =>
           val tparams = tparamRefs.map(_.typeSymbol.asType)
           val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
-          tparams.foreach(ctx.enter)
-          params.foreach(ctx.enter)
+          tparams.foreach(sym => ctx.enter(sym))
+          params.foreach(sym => ctx.enter(sym))
           def instantiated(info: Type): Type = info match {
             case info: PolyType => instantiated(info.instantiate(tparamRefs))
             case info: MethodType => info.instantiate(params.map(_.termRef))