Refactor TASYy reflect TermRef, TypeRef and SymRef

* Split into SymRef into TermRef, TypeRef
* Rename old TermRef/TypeRef to NamedTermRef/NamedTypeRef

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionInternal.scala renamed to compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -282,7 +282,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   def Ident_name(self: Ident) given Context: String = self.name.show
 
-  def Ident_apply(tmref: TermRef) given Context: Term =
+  def Ident_apply(tmref: NamedTermRef) given Context: Term =
     withDefaultPos(tpd.ref(tmref).asInstanceOf[Term])
 
   def Ident_copy(original: Tree)(name: String) given Context: Ident =
@@ -1145,32 +1145,53 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   def ConstantType_constant(self: ConstantType) given Context: Constant = self.value
 
-  type SymRef = Types.NamedType
+  type TermRef = Types.NamedType
 
-  def matchSymRef(tpe: TypeOrBounds) given Context: Option[SymRef] = tpe match {
+  def matchTermRef(tpe: TypeOrBounds) given Context: Option[TermRef] = tpe match {
     case tp: Types.NamedType =>
       tp.designator match {
-        case sym: Symbol => Some(tp)
+        case sym: Symbol if sym.isTerm => Some(tp)
         case _ => None
       }
     case _ => None
   }
 
-  def SymRef_qualifier(self: SymRef) given Context: TypeOrBounds = self.prefix
+  def TermRef_qualifier(self: TermRef) given Context: TypeOrBounds = self.prefix
 
-  // TODO remove this method. May require splitting SymRef into TypeSymRef and TermSymRef
-  def matchSymRef_unapply(tpe: TypeOrBounds) given Context: Option[(Symbol, Type | NoPrefix)] = tpe match {
+  def matchTermRef_unapply(tpe: TypeOrBounds) given Context: Option[(Symbol, Type | NoPrefix)] = tpe match {
     case tpe: Types.NamedType =>
       tpe.designator match {
-        case sym: Symbol => Some((sym, tpe.prefix))
+        case sym: Symbol if sym.isTerm => Some((sym, tpe.prefix))
         case _ => None
       }
     case _ => None
   }
 
-  type TermRef = Types.NamedType
+  type TypeRef = Types.NamedType
 
-  def matchTermRef(tpe: TypeOrBounds) given Context: Option[TermRef] = tpe match {
+  def matchTypeRef(tpe: TypeOrBounds) given Context: Option[TypeRef] = tpe match {
+    case tp: Types.NamedType =>
+      tp.designator match {
+        case sym: Symbol if sym.isType => Some(tp)
+        case _ => None
+      }
+    case _ => None
+  }
+
+  def TypeRef_qualifier(self: TypeRef) given Context: TypeOrBounds = self.prefix
+
+  def matchTypeRef_unapply(tpe: TypeOrBounds) given Context: Option[(Symbol, Type | NoPrefix)] = tpe match {
+    case tpe: Types.NamedType =>
+      tpe.designator match {
+        case sym: Symbol if sym.isType => Some((sym, tpe.prefix))
+        case _ => None
+      }
+    case _ => None
+  }
+
+  type NamedTermRef = Types.NamedType
+
+  def matchNamedTermRef(tpe: TypeOrBounds) given Context: Option[NamedTermRef] = tpe match {
     case tpe: Types.NamedType =>
       tpe.designator match {
         case name: Names.TermName => Some(tpe)
@@ -1179,15 +1200,15 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     case _ => None
   }
 
-  def TermRef_name(self: TermRef) given Context: String = self.name.toString
-  def TermRef_qualifier(self: TermRef) given Context: TypeOrBounds = self.prefix
+  def NamedTermRef_name(self: NamedTermRef) given Context: String = self.name.toString
+  def NamedTermRef_qualifier(self: NamedTermRef) given Context: TypeOrBounds = self.prefix
 
-  def TermRef_apply(qual: TypeOrBounds, name: String) given Context: TermRef =
+  def NamedTermRef_apply(qual: TypeOrBounds, name: String) given Context: NamedTermRef =
     Types.TermRef(qual, name.toTermName)
 
-  type TypeRef = Types.NamedType
+  type NamedTypeRef = Types.NamedType
 
-  def matchTypeRef(tpe: TypeOrBounds) given Context: Option[TypeRef] = tpe match {
+  def matchNamedTypeRef(tpe: TypeOrBounds) given Context: Option[NamedTypeRef] = tpe match {
     case tpe: Types.NamedType =>
       tpe.designator match {
         case name: Names.TypeName => Some(tpe)
@@ -1196,8 +1217,8 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     case _ => None
   }
 
-  def TypeRef_name(self: TypeRef) given Context: String = self.name.toString
-  def TypeRef_qualifier(self: TypeRef) given Context: TypeOrBounds = self.prefix
+  def NamedTypeRef_name(self: NamedTypeRef) given Context: String = self.name.toString
+  def NamedTypeRef_qualifier(self: NamedTypeRef) given Context: TypeOrBounds = self.prefix
 
   type SuperType = Types.SuperType
 

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -72,9 +72,10 @@ import scala.runtime.quoted.Unpickler
  *  +- TypeOrBounds -+- TypeBounds
  *                   |
  *                   +- Type -------+- ConstantType
- *                                  +- SymRef
  *                                  +- TermRef
  *                                  +- TypeRef
+ *                                  +- NamedTermRef
+ *                                  +- NamedTypeRef
  *                                  +- SuperType
  *                                  +- Refinement
  *                                  +- AppliedType
@@ -329,7 +330,7 @@ trait CompilerInterface {
 
   def Ident_name(self: Ident) given (ctx: Context): String
 
-  def Ident_apply(tmref: TermRef) given (ctx: Context): Term
+  def Ident_apply(tmref: NamedTermRef) given (ctx: Context): Term
   def Ident_copy(original: Tree)(name: String) given (ctx: Context): Ident
 
   /** Tree representing a selection of definition with a given name on a given prefix */
@@ -925,34 +926,42 @@ trait CompilerInterface {
 
   def ConstantType_constant(self: ConstantType) given (ctx: Context): Constant
 
-  /** Type of a reference to a symbol */
-  type SymRef <: Type
-
-  def matchSymRef(tpe: TypeOrBounds) given (ctx: Context): Option[SymRef]
-
-  // TODO remove this method. May require splitting SymRef into TypeSymRef and TermSymRef
-  def matchSymRef_unapply(tpe: TypeOrBounds) given (ctx: Context): Option[(Symbol, TypeOrBounds /* Type | NoPrefix */)]
-
-  def SymRef_qualifier(self: SymRef) given (ctx: Context): TypeOrBounds
-
-  /** Type of a reference to a term */
+  /** Type of a reference to a term symbol */
   type TermRef <: Type
 
   def matchTermRef(tpe: TypeOrBounds) given (ctx: Context): Option[TermRef]
 
-  def TermRef_name(self: TermRef) given (ctx: Context): String
-  def TermRef_qualifier(self: TermRef) given (ctx: Context): TypeOrBounds
+  def matchTermRef_unapply(tpe: TypeOrBounds) given (ctx: Context): Option[(Symbol, TypeOrBounds /* Type | NoPrefix */)]
 
-  def TermRef_apply(qual: TypeOrBounds, name: String) given (ctx: Context): TermRef
+  def TermRef_qualifier(self: TermRef) given (ctx: Context): TypeOrBounds
 
-  /** Type of a reference to a type */
+  /** Type of a reference to a type symbol */
   type TypeRef <: Type
 
   def matchTypeRef(tpe: TypeOrBounds) given (ctx: Context): Option[TypeRef]
 
-  def TypeRef_name(self: TypeRef) given (ctx: Context): String
+  def matchTypeRef_unapply(tpe: TypeOrBounds) given (ctx: Context): Option[(Symbol, TypeOrBounds /* Type | NoPrefix */)]
+
   def TypeRef_qualifier(self: TypeRef) given (ctx: Context): TypeOrBounds
 
+  /** Type of a reference to a term by it's name */
+  type NamedTermRef <: Type
+
+  def matchNamedTermRef(tpe: TypeOrBounds) given (ctx: Context): Option[NamedTermRef]
+
+  def NamedTermRef_name(self: NamedTermRef) given (ctx: Context): String
+  def NamedTermRef_qualifier(self: NamedTermRef) given (ctx: Context): TypeOrBounds
+
+  def NamedTermRef_apply(qual: TypeOrBounds, name: String) given (ctx: Context): NamedTermRef
+
+  /** Type of a reference to a type by it's name */
+  type NamedTypeRef <: Type
+
+  def matchNamedTypeRef(tpe: TypeOrBounds) given (ctx: Context): Option[NamedTypeRef]
+
+  def NamedTypeRef_name(self: NamedTypeRef) given (ctx: Context): String
+  def NamedTypeRef_qualifier(self: NamedTypeRef) given (ctx: Context): TypeOrBounds
+
   /** Type of a `super` refernce */
   type SuperType <: Type
 

library/src/scala/tasty/reflect/Core.scala

@@ -69,9 +69,10 @@ package scala.tasty.reflect
  *  +- TypeOrBounds -+- TypeBounds
  *                   |
  *                   +- Type -------+- ConstantType
- *                                  +- SymRef
  *                                  +- TermRef
  *                                  +- TypeRef
+ *                                  +- NamedTermRef
+ *                                  +- NamedTypeRef
  *                                  +- SuperType
  *                                  +- Refinement
  *                                  +- AppliedType
@@ -331,14 +332,17 @@ trait Core {
       /** A singleton type representing a known constant value */
       type ConstantType = internal.ConstantType
 
-      /** Type of a reference to a symbol */
-      type SymRef = internal.SymRef
+      /** Type of a reference to a term symbol */
+      type TermRef = internal.TermRef
+
+      /** Type of a reference to a type symbol */
+      type TypeRef = internal.TypeRef
 
       /** Type of a reference to a term */
-      type TermRef = internal.TermRef
+      type NamedTermRef = internal.NamedTermRef
 
       /** Type of a reference to a type */
-      type TypeRef = internal.TypeRef
+      type NamedTypeRef = internal.NamedTypeRef
 
       /** Type of a `super` refernce */
       type SuperType = internal.SuperType