Drop DenotationsBase mixin of ContextBase

Author: odersky

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

@@ -656,7 +656,6 @@ object Contexts {
    *  compiler run.
    */
   class ContextBase extends ContextState
-                       with Denotations.DenotationsBase
                        with Phases.PhasesBase
                        with Plugins {
 

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

@@ -1189,72 +1189,67 @@ object Denotations {
         s"multi-denotation with alternatives $alternatives does not implement operation $op")
   }
 
-  // --------------- Context Base Trait -------------------------------
-
-  trait DenotationsBase { this: ContextBase =>
-
-    /** The current denotation of the static reference given by path,
-     *  or a MissingRef or NoQualifyingRef instance, if it does not exist.
-     *  if generateStubs is set, generates stubs for missing top-level symbols
-     */
-    def staticRef(path: Name, generateStubs: Boolean = true, isPackage: Boolean = false)(using Context): Denotation = {
-      def select(prefix: Denotation, selector: Name): Denotation = {
-        val owner = prefix.disambiguate(_.info.isParameterless)
-        def isPackageFromCoreLibMissing: Boolean =
-          owner.symbol == defn.RootClass &&
-          (
-            selector == nme.scala || // if the scala package is missing, the stdlib must be missing
-            selector == nme.scalaShadowing // if the scalaShadowing package is missing, the dotty library must be missing
-          )
-        if (owner.exists) {
-          val result = if (isPackage) owner.info.decl(selector) else owner.info.member(selector)
-          if (result.exists) result
-          else if (isPackageFromCoreLibMissing) throw new MissingCoreLibraryException(selector.toString)
-          else {
-            val alt =
-              if (generateStubs) missingHook(owner.symbol.moduleClass, selector)
-              else NoSymbol
-            if (alt.exists) alt.denot
-            else MissingRef(owner, selector)
-          }
+  /** The current denotation of the static reference given by path,
+    *  or a MissingRef or NoQualifyingRef instance, if it does not exist.
+    *  if generateStubs is set, generates stubs for missing top-level symbols
+    */
+  def staticRef(path: Name, generateStubs: Boolean = true, isPackage: Boolean = false)(using Context): Denotation = {
+    def select(prefix: Denotation, selector: Name): Denotation = {
+      val owner = prefix.disambiguate(_.info.isParameterless)
+      def isPackageFromCoreLibMissing: Boolean =
+        owner.symbol == defn.RootClass &&
+        (
+          selector == nme.scala || // if the scala package is missing, the stdlib must be missing
+          selector == nme.scalaShadowing // if the scalaShadowing package is missing, the dotty library must be missing
+        )
+      if (owner.exists) {
+        val result = if (isPackage) owner.info.decl(selector) else owner.info.member(selector)
+        if (result.exists) result
+        else if (isPackageFromCoreLibMissing) throw new MissingCoreLibraryException(selector.toString)
+        else {
+          val alt =
+            if (generateStubs) missingHook(owner.symbol.moduleClass, selector)
+            else NoSymbol
+          if (alt.exists) alt.denot
+          else MissingRef(owner, selector)
         }
-        else owner
       }
-      def recur(path: Name, wrap: TermName => Name = identity): Denotation = path match {
-        case path: TypeName =>
-          recur(path.toTermName, n => n.toTypeName)
-        case ModuleClassName(underlying) =>
-          recur(underlying, n => wrap(ModuleClassName(n)))
-        case QualifiedName(prefix, selector) =>
-          select(recur(prefix), wrap(selector))
-        case qn @ AnyQualifiedName(prefix, _) =>
-          recur(prefix, n => wrap(qn.info.mkString(n).toTermName))
-        case path: SimpleName =>
-          def recurSimple(len: Int, wrap: TermName => Name): Denotation = {
-            val point = path.lastIndexOf('.', len - 1)
-            val selector = wrap(path.slice(point + 1, len).asTermName)
-            val prefix =
-              if (point > 0) recurSimple(point, identity)
-              else if (selector.isTermName) defn.RootClass.denot
-              else defn.EmptyPackageClass.denot
-            select(prefix, selector)
-          }
-          recurSimple(path.length, wrap)
-      }
-      recur(path)
+      else owner
     }
-
-    /** If we are looking for a non-existing term name in a package,
-     *  assume it is a package for which we do not have a directory and
-     *  enter it.
-     */
-    def missingHook(owner: Symbol, name: Name)(using Context): Symbol =
-      if (owner.is(Package) && name.isTermName)
-        newCompletePackageSymbol(owner, name.asTermName).entered
-      else
-        NoSymbol
+    def recur(path: Name, wrap: TermName => Name = identity): Denotation = path match {
+      case path: TypeName =>
+        recur(path.toTermName, n => n.toTypeName)
+      case ModuleClassName(underlying) =>
+        recur(underlying, n => wrap(ModuleClassName(n)))
+      case QualifiedName(prefix, selector) =>
+        select(recur(prefix), wrap(selector))
+      case qn @ AnyQualifiedName(prefix, _) =>
+        recur(prefix, n => wrap(qn.info.mkString(n).toTermName))
+      case path: SimpleName =>
+        def recurSimple(len: Int, wrap: TermName => Name): Denotation = {
+          val point = path.lastIndexOf('.', len - 1)
+          val selector = wrap(path.slice(point + 1, len).asTermName)
+          val prefix =
+            if (point > 0) recurSimple(point, identity)
+            else if (selector.isTermName) defn.RootClass.denot
+            else defn.EmptyPackageClass.denot
+          select(prefix, selector)
+        }
+        recurSimple(path.length, wrap)
+    }
+    recur(path)
   }
 
+  /** If we are looking for a non-existing term name in a package,
+    *  assume it is a package for which we do not have a directory and
+    *  enter it.
+    */
+  def missingHook(owner: Symbol, name: Name)(using Context): Symbol =
+    if (owner.is(Package) && name.isTermName)
+      newCompletePackageSymbol(owner, name.asTermName).entered
+    else
+      NoSymbol
+
   /** An exception for accessing symbols that are no longer valid in current run */
   class StaleSymbol(msg: => String) extends Exception {
     util.Stats.record("stale symbol")

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

@@ -11,6 +11,7 @@ import Symbols._
 import Contexts._
 import Phases._
 import SymDenotations._
+import Denotations._
 import printing.Texts._
 import printing.Printer
 import Types._
@@ -882,14 +883,14 @@ object Symbols {
 
   def requiredPackage(path: PreName)(using Context): TermSymbol = {
     val name = path.toTermName
-    ctx.base.staticRef(name, isPackage = true).requiredSymbol("package", name)(_.is(Package)).asTerm
+    staticRef(name, isPackage = true).requiredSymbol("package", name)(_.is(Package)).asTerm
   }
 
   def requiredPackageRef(path: PreName)(using Context): TermRef = requiredPackage(path).termRef
 
   def requiredClass(path: PreName)(using Context): ClassSymbol = {
     val name = path.toTypeName
-    ctx.base.staticRef(name).requiredSymbol("class", name)(_.isClass) match {
+    staticRef(name).requiredSymbol("class", name)(_.isClass) match {
       case cls: ClassSymbol => cls
       case sym => defn.AnyClass
     }
@@ -902,7 +903,7 @@ object Symbols {
    *  Returns NoSymbol otherwise. */
   def getClassIfDefined(path: PreName)(using Context): Symbol = {
     val name = path.toTypeName
-    ctx.base.staticRef(name, generateStubs = false)
+    staticRef(name, generateStubs = false)
       .requiredSymbol("class", name, generateStubs = false)(_.isClass)
   }
 
@@ -917,20 +918,20 @@ object Symbols {
    *  Returns NoSymbol otherwise. */
   def getPackageClassIfDefined(path: PreName)(using Context): Symbol = {
     val name = path.toTypeName
-    ctx.base.staticRef(name, isPackage = true, generateStubs = false)
+    staticRef(name, isPackage = true, generateStubs = false)
       .requiredSymbol("package", name, generateStubs = false)(_ is PackageClass)
   }
 
   def requiredModule(path: PreName)(using Context): TermSymbol = {
     val name = path.toTermName
-    ctx.base.staticRef(name).requiredSymbol("object", name)(_.is(Module)).asTerm
+    staticRef(name).requiredSymbol("object", name)(_.is(Module)).asTerm
   }
 
   def requiredModuleRef(path: PreName)(using Context): TermRef = requiredModule(path).termRef
 
   def requiredMethod(path: PreName)(using Context): TermSymbol = {
     val name = path.toTermName
-    ctx.base.staticRef(name).requiredSymbol("method", name)(_.is(Method)).asTerm
+    staticRef(name).requiredSymbol("method", name)(_.is(Method)).asTerm
   }
 
   def requiredMethodRef(path: PreName)(using Context): TermRef = requiredMethod(path).termRef

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

@@ -411,7 +411,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           // (3) Try as a nested object symbol.
           nestedObjectSymbol orElse {
             // (4) Call the mirror's "missing" hook.
-            adjust(ctx.base.missingHook(owner, name)) orElse {
+            adjust(missingHook(owner, name)) orElse {
               // println(owner.info.decls.toList.map(_.debugString).mkString("\n  ")) // !!! DEBUG
               //              }
               // (5) Create a stub symbol to defer hard failure a little longer.

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -7,6 +7,7 @@ import Decorators._
 import Contexts.{Context, ctx}
 import Symbols.{Symbol, ClassSymbol}
 import SymDenotations.ClassDenotation
+import Denotations.staticRef
 import NameOps._
 import ast.Trees.Tree
 import Phases.Phase
@@ -59,7 +60,7 @@ class ReadTasty extends Phase {
       // Note that if both the class and the object are present, then loading the class will also load
       // the object, this is why we use orElse here, otherwise we could load the object twice and
       // create ambiguities!
-      ctx.base.staticRef(className) match {
+      staticRef(className) match {
         case clsd: ClassDenotation =>
           clsd.infoOrCompleter match {
             case info: ClassfileLoader =>

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

@@ -16,6 +16,7 @@ import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation, PlainFile,
 import ast.{Trees, tpd}
 import core._, core.Decorators._
 import Contexts._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
+import Denotations.staticRef
 import classpath._
 import reporting._
 import util._
@@ -184,7 +185,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
    */
   private def treesFromClassName(className: TypeName, id: String)(using Context): List[SourceTree] = {
     def trees(className: TypeName, id: String): List[SourceTree] = {
-      val clsd = ctx.base.staticRef(className)
+      val clsd = staticRef(className)
       clsd match {
         case clsd: ClassDenotation =>
           clsd.ensureCompleted()

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

@@ -15,6 +15,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.quoted._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Denotations.staticRef
 import dotty.tools.dotc.core.{NameKinds, TypeErasure}
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.tastyreflect.ReflectionImpl
@@ -418,7 +419,7 @@ object Splicer {
         val className = targetException.getMessage
         if (className eq null) None
         else {
-          val sym = ctx.base.staticRef(className.toTypeName).symbol
+          val sym = staticRef(className.toTypeName).symbol
           if (sym.isDefinedInCurrentRun) Some(sym) else None
         }
       }

compiler/test/dotty/tools/AnnotationsTests.scala

@@ -9,11 +9,11 @@ import dotc.core.Decorators._
 import dotc.core.Contexts._
 import dotc.core.Phases._
 import dotc.core.Types._
+import dotc.core.Symbols._
 
 import java.io.File
 import java.nio.file._
 
-class AnnotationsTest:
   @Test def annotTreeNotErased: Unit =
     withJavaCompiled(
       VirtualJavaSource("Annot.java",

compiler/test/dotty/tools/SignatureTest.scala

@@ -9,6 +9,7 @@ import dotc.core.Decorators._
 import dotc.core.Contexts._
 import dotc.core.Phases._
 import dotc.core.Types._
+import dotc.core.Symbols._
 
 import java.io.File
 import java.nio.file._

staging/src/scala/quoted/staging/QuoteCompiler.scala

@@ -12,7 +12,7 @@ import dotty.tools.dotc.core.Names.TypeName
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Scopes.{EmptyScope, newScope}
 import dotty.tools.dotc.core.StdNames.nme
-import dotty.tools.dotc.core.Symbols.defn
+import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types.ExprType
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.tastyreflect.ReflectionImpl
@@ -62,10 +62,10 @@ private class QuoteCompiler extends Compiler:
 
           // Places the contents of expr in a compilable tree for a class with the following format.
           // `package __root__ { class ' { def apply: Any = <expr> } }`
-          val cls = unitCtx.newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
+          val cls = newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
             defn.ObjectType :: Nil, newScope, coord = pos, assocFile = assocFile).entered.asClass
-          cls.enter(unitCtx.newDefaultConstructor(cls), EmptyScope)
-          val meth = unitCtx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
+          cls.enter(newDefaultConstructor(cls), EmptyScope)
+          val meth = newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
 
           val quoted =
             given Context = unitCtx.withOwner(meth)