Drop toClassDenot implicit conversion

Author: odersky

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -94,7 +94,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
 
   private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = {
     val superClassSym: Symbol =  {
-      val t = classSym.asClass.superClass
+      val t = classSym.classDenot.superClass
       if (t.exists) t
       else if (classSym.is(ModuleClass)) {
         // workaround #371
@@ -124,7 +124,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     def (sym: Symbol).superInterfaces: List[Symbol] = {
       val directlyInheritedTraits = sym.directlyInheritedTraits
       val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
-      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
+      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.classDenot.baseClasses.drop(1)).toSet
       val superCalls = superCallsMap.getOrElse(sym, Set.empty)
       val additional = (superCalls -- directlyInheritedTraitsSet).filter(_.is(Trait))
 //      if (additional.nonEmpty)

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -78,9 +78,9 @@ object CompilationUnit {
 
   class SuspendException extends Exception
 
-  /** Make a compilation unit for top class `clsd` with the contents of the `unpickled` tree */
-  def apply(clsd: ClassDenotation, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
-    apply(new SourceFile(clsd.symbol.associatedFile, Array.empty[Char]), unpickled, forceTrees)
+  /** Make a compilation unit for top class `cls` with the contents of the `unpickled` tree */
+  def apply(cls: ClassSymbol, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit =
+    apply(new SourceFile(cls.associatedFile, Array.empty[Char]), unpickled, forceTrees)
 
   /** Make a compilation unit, given picked bytes and unpickled tree */
   def apply(source: SourceFile, unpickled: Tree, forceTrees: Boolean)(implicit ctx: Context): CompilationUnit = {

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

@@ -69,8 +69,8 @@ class TreeTypeMap(
         case pdef: MemberDef =>
           val prevSym = pdef.symbol
           val newSym = newStats.head.symbol
-          val newCls = newSym.owner.asClass
-          if (prevSym != newSym) newCls.replace(prevSym, newSym)
+          if prevSym != newSym then
+            newSym.owner.classDenot.replace(prevSym, newSym)
         case _ =>
       }
       updateDecls(prevStats.tail, newStats.tail)
@@ -191,7 +191,7 @@ class TreeTypeMap(
       val mappedDcls = ctx.mapSymbols(origDcls, tmap)
       val tmap1 = tmap.withMappedSyms(origDcls, mappedDcls)
       if (symsChanged)
-        origDcls.lazyZip(mappedDcls).foreach(cls.asClass.replace)
+        origDcls.lazyZip(mappedDcls).foreach(cls.classDenot.replace)
       tmap1
     }
     if (symsChanged || (fullMap eq substMap)) fullMap

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

@@ -174,7 +174,7 @@ class CheckRealizable(implicit ctx: Context) {
         }
     }
     val baseProblems =
-      tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
+      tp.baseClasses.map(_.classDenot.baseTypeOf(tp)).flatMap(baseTypeProblems)
 
     baseProblems.foldLeft(
       refinementProblems.foldLeft(

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

@@ -77,7 +77,7 @@ object SymbolLoaders {
       if (ctx.settings.YtermConflict.value == "package" || ctx.mode.is(Mode.Interactive)) {
         ctx.warning(
           s"Resolving package/object name conflict in favor of package ${preExisting.fullName}. The object will be inaccessible.")
-        owner.asClass.delete(preExisting)
+        owner.classDenot.delete(preExisting)
       }
       else if (ctx.settings.YtermConflict.value == "object") {
         ctx.warning(

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

@@ -10,6 +10,7 @@ import Decorators._
 import Symbols._
 import Contexts._
 import SymDenotations._
+import Denotations.PreDenotation
 import printing.Texts._
 import printing.Printer
 import Types._
@@ -508,6 +509,9 @@ object Symbols {
     final def lastKnownDenotation: SymDenotation =
       lastDenot
 
+    final def classDenot(using Context): ClassDenotation =
+      denot.asInstanceOf[ClassDenotation]
+
     private[core] def defRunId: RunId =
       if (lastDenot == null) NoRunId else lastDenot.validFor.runId
 
@@ -590,16 +594,16 @@ object Symbols {
             denot.validFor |= InitialPeriod
             if (this.is(Module)) this.moduleClass.validFor |= InitialPeriod
           }
-          else owner.ensureFreshScopeAfter(phase)
+          else owner.classDenot.ensureFreshScopeAfter(phase)
           assert(isPrivate || phase.changesMembers, i"$this entered in $owner at undeclared phase $phase")
           entered
         case _ => this
       }
 
     /** Remove symbol from scope of owning class */
     final def drop()(implicit ctx: Context): Unit = {
-      this.owner.asClass.delete(this)
-      if (this.is(Module)) this.owner.asClass.delete(this.moduleClass)
+      this.owner.classDenot.delete(this)
+      if (this.is(Module)) this.owner.classDenot.delete(this.moduleClass)
     }
 
     /** Remove symbol from scope of owning class after given `phase`. Create a fresh
@@ -610,7 +614,7 @@ object Symbols {
       if (ctx.phaseId != phase.next.id) dropAfter(phase)(ctx.withPhase(phase.next))
       else {
         assert (!this.owner.is(Package))
-        this.owner.asClass.ensureFreshScopeAfter(phase)
+        this.owner.classDenot.ensureFreshScopeAfter(phase)
         assert(isPrivate || phase.changesMembers, i"$this deleted in ${this.owner} at undeclared phase $phase")
         drop()
       }
@@ -818,10 +822,30 @@ object Symbols {
       mySource
     }
 
-    final def classDenot(implicit ctx: Context): ClassDenotation =
-      denot.asInstanceOf[ClassDenotation]
-
     override protected def prefixString: String = "ClassSymbol"
+
+
+    // ClassDenotation forwarders
+    final def classInfo(using Context): ClassInfo =
+      classDenot.classInfo
+    final def superClass(using Context): Symbol =
+      classDenot.superClass
+    final def classParents(using Context): List[Type] =
+      classDenot.classParents
+    final def baseClasses(using BaseData, Context): List[ClassSymbol] =
+      classDenot.baseClasses
+    final def givenSelfType(using Context): Type =
+      classDenot.givenSelfType
+    final def paramAccessors(using Context): List[Symbol] =
+      classDenot.paramAccessors
+    final def memberNames(keepOnly: NameFilter)(using MemberNames, Context) =
+      classDenot.memberNames(keepOnly)
+    final def membersNamed(name: Name)(using Context): PreDenotation =
+      classDenot.membersNamed(name)
+    final def nonPrivateMembersNamed(name: Name)(using Context): PreDenotation =
+      classDenot.nonPrivateMembersNamed(name)
+    final def enter(sym: Symbol, scope: Scope = EmptyScope)(using Context): Unit =
+      classDenot.enter(sym, scope)
   }
 
   @sharable object NoSymbol extends Symbol(NoCoord, 0) {
@@ -859,7 +883,7 @@ object Symbols {
   implicit def toDenot(sym: Symbol)(implicit ctx: Context): SymDenotation = sym.denot
 
   /** Makes all class denotation operations available on class symbols */
-  implicit def toClassDenot(cls: ClassSymbol)(implicit ctx: Context): ClassDenotation = cls.classDenot
+  def toClassDenot(cls: ClassSymbol)(using Context): ClassDenotation = cls.classDenot
 
   /** The Definitions object */
   def defn(implicit ctx: Context): Definitions = ctx.definitions

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

@@ -196,10 +196,10 @@ class ClassfileParser(
     }
     else if (result == Some(NoEmbedded))
       for (sym <- List(moduleRoot.sourceModule, moduleRoot.symbol, classRoot.symbol)) {
-        classRoot.owner.asClass.delete(sym)
+        classRoot.owner.classDenot.delete(sym)
         if (classRoot.owner == defn.ScalaShadowingPackage.moduleClass)
           // Symbols in scalaShadowing are also added to scala
-          defn.ScalaPackageClass.delete(sym)
+          defn.ScalaPackageClass.classDenot.delete(sym)
         sym.markAbsent()
       }
 

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

@@ -94,7 +94,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     bridgesScope.enter(bridge)
 
     if (other.owner == root) {
-      root.delete(other)
+      root.classDenot.delete(other)
       toBeRemoved += other
     }
 

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

@@ -26,7 +26,7 @@ class MoveStatics extends MiniPhase with SymTransformer {
   def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
     if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists &&
         (sym.is(Flags.Method) || !(sym.is(Flags.Mutable) && sym.owner.companionClass.is(Flags.Trait)))) {
-      sym.owner.asClass.delete(sym.symbol)
+      sym.owner.classDenot.delete(sym.symbol)
       sym.owner.companionClass.asClass.enter(sym.symbol)
       sym.copySymDenotation(owner = sym.owner.companionClass)
     }

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

@@ -150,7 +150,7 @@ object TypeTestsCasts {
           case _ =>
             // always false test warnings are emitted elsewhere
             X.classSymbol.exists && P.classSymbol.exists &&
-              !X.classSymbol.asClass.mayHaveCommonChild(P.classSymbol.asClass) ||
+              !X.classSymbol.classDenot.mayHaveCommonChild(P.classSymbol.asClass) ||
             // first try without striping type parameters for performance
             typeArgsTrivial(X, tpe) ||
             typeArgsTrivial(stripTypeParam(X), tpe)

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

@@ -1328,7 +1328,7 @@ class Namer { typer: Typer =>
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
       cls.info = avoidPrivateLeaks(cls)
-      cls.baseClasses.foreach(_.invalidateBaseTypeCache()) // we might have looked before and found nothing
+      cls.baseClasses.foreach(_.classDenot.invalidateBaseTypeCache()) // we might have looked before and found nothing
       cls.setNoInitsFlags(parentsKind(parents), untpd.bodyKind(rest))
       if (cls.isNoInitsClass) cls.primaryConstructor.setFlag(StableRealizable)
       processExports(localCtx)

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

@@ -97,7 +97,7 @@ object RefChecks {
       def checkSelfConforms(other: ClassSymbol, category: String, relation: String) = {
         val otherSelf = other.declaredSelfTypeAsSeenFrom(cls.thisType)
         if otherSelf.exists && !(cinfo.selfType <:< otherSelf) then
-          ctx.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other.classSymbol),
+          ctx.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other),
             cls.sourcePos)
       }
       for (parent <- cinfo.classParents)