Make designator a union type

Author: odersky

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

@@ -20,17 +20,12 @@ object Names {
    */
   type PreName = Name | String
 
-  /** A common superclass of Name and Symbol. After bootstrap, this should be
-   *  just the type alias Name | Symbol
-   */
-  abstract class Designator
-
   /** A name is either a term name or a type name. Term names can be simple
    *  or derived. A simple term name is essentially an interned string stored
    *  in a name table. A derived term name adds a tag, and possibly a number
    *  or a further simple name to some other name.
    */
-  abstract class Name extends Designator, Showable derives CanEqual {
+  abstract class Name extends Showable derives CanEqual {
 
     /** A type for names of the same kind as this name */
     type ThisName <: Name

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

@@ -2662,7 +2662,7 @@ object SymDenotations {
             if (!traceInvalid(owner)) explainSym("owner is invalid")
             else if (!owner.isClass || owner.isRefinementClass || denot.isSelfSym) true
             else if (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol) true
-            else explainSym(s"decls of ${show(owner)} are ${owner.unforcedDecls.lookupAll(denot.name).toList}, do not contain ${denot.symbol}")
+            else explainSym(s"decls of ${show(owner)} are ${owner.unforcedDecls.lookupAll(denot.name).toList.map(show(_))}, do not contain ${denot.symbol}")
           }
           catch {
             case ex: StaleSymbol => explainSym(s"$ex was thrown")

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

@@ -44,7 +44,7 @@ object Symbols {
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
    */
   class Symbol private[Symbols] (private var myCoord: Coord, val id: Int, val nestingLevel: Int)
-    extends Designator, ParamInfo, SrcPos, printing.Showable {
+    extends ParamInfo, SrcPos, printing.Showable {
 
     type ThisName <: Name
 

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

@@ -2179,6 +2179,8 @@ object Types {
 
 // --- NamedTypes ------------------------------------------------------------------
 
+  type Designator = Name | Symbol
+
   abstract class NamedType extends CachedProxyType, ValueType { self =>
 
     type ThisType >: this.type <: NamedType
@@ -2444,11 +2446,12 @@ object Types {
         checkSymAssign(denot.symbol)
 
       lastDenotation = denot
-      lastSymbol = denot.symbol
+      val lastSym = denot.symbol.asInstanceOf[Symbol]
+      lastSymbol = lastSym
       checkedPeriod = if (prefix.isProvisional) Nowhere else ctx.period
       designator match {
-        case sym: Symbol if designator ne lastSymbol.nn =>
-          designator = lastSymbol.asInstanceOf[Designator{ type ThisName = self.ThisName }]
+        case sym: Symbol if designator ne lastSym =>
+          designator = lastSym
         case _ =>
       }
       checkDenot()

compiler/src/dotty/tools/dotc/printing/Formatting.scala

@@ -9,6 +9,7 @@ import scala.collection.mutable
 import core._
 import Texts._, Types._, Flags._, Symbols._, Contexts._
 import Decorators._
+import Names.Name
 import reporting.Message
 import util.DiffUtil
 import Highlighting._
@@ -22,7 +23,7 @@ object Formatting {
      *  interpolator's correct context, that is with non-sensical tagging, message limiting, explanations, etc. */
     opaque type Shown = Any
     object Shown:
-      given [A: Show]: Conversion[A, Shown] = Show[A].show(_)
+      given toShown[A: Show]: Conversion[A, Shown] = Show[A].show(_)
 
     sealed abstract class Show[-T]:
       /** Show a value T by returning a "shown" result. */
@@ -48,7 +49,6 @@ object Formatting {
 
     class ShowImplicits1 extends ShowImplicits2:
       given Show[ImplicitRef]      = ShowAny
-      given Show[Names.Designator] = ShowAny
       given Show[util.SrcPos]      = ShowAny
 
     object Show extends ShowImplicits1:
@@ -90,6 +90,8 @@ object Formatting {
       given Show[util.SourceFile]                     = ShowAny
       given Show[util.Spans.Span]                     = ShowAny
       given Show[tasty.TreeUnpickler#OwnerTree]       = ShowAny
+      given Show[Name]                                = ShowAny
+      given Show[Symbol]                              = ShowAny
 
       private def show1[A: Show](x: A)(using Context) = show2(Show[A].show(x).ctxShow)
       private def show2(x: Shown)(using Context): String = x match

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -5,14 +5,13 @@ import core.Symbols.{ Symbol , defn, NoSymbol }
 import core.Contexts._
 import core.Names
 import core.Names.Name
-import core.Types.{Type, TypeBounds}
+import core.Types.{Type, TypeBounds, Designator}
 import core.Flags._
 import core.NameKinds
 import core.StdNames.nme
 import SymbolInformation.{Kind => k}
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.util.Spans.Span
-import dotty.tools.dotc.core.Names.Designator
 
 import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart}
 

compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala

@@ -15,7 +15,6 @@ import collection.mutable
 
 import dotty.tools.dotc.{semanticdb => s}
 import Scala3.{FakeSymbol, SemanticSymbol, WildcardTypeSymbol, TypeParamRefSymbol, TermParamRefSymbol, RefinementSymbol}
-import dotty.tools.dotc.core.Names.Designator
 
 class TypeOps:
   import SymbolScopeOps._