Join TermRef/TypeRef with NamedTermRef/NamedTypeRef

Author: nicolasstucki

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: NamedTermRef) given Context: Term =
+  def Ident_apply(tmref: TermRef) given Context: Term =
     withDefaultPos(tpd.ref(tmref).asInstanceOf[Term])
 
   def Ident_copy(original: Tree)(name: String) given Context: Ident =
@@ -1150,26 +1150,21 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   type TermRef = Types.NamedType
 
   def matchTermRef(tpe: TypeOrBounds) given Context: Option[TermRef] = tpe match {
-    case tp: Types.NamedType =>
-      tp.designator match {
-        case sym: Symbol if sym.isTerm => Some(tp)
-        case _ => None
-      }
+    case tp: Types.TermRef => Some(tp)
     case _ => None
   }
 
+  def TermRef_apply(qual: TypeOrBounds, name: String) given Context: TermRef =
+    Types.TermRef(qual, name.toTermName)
+
   def TermRef_qualifier(self: TermRef) given Context: TypeOrBounds = self.prefix
 
   def TermRef_name(self: TermRef) given Context: String = self.name.toString
 
   type TypeRef = Types.NamedType
 
   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 tp: Types.TypeRef => Some(tp)
     case _ => None
   }
 
@@ -1191,23 +1186,6 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def NamedTermRef_name(self: NamedTermRef) given Context: String = self.name.toString
   def NamedTermRef_qualifier(self: NamedTermRef) given Context: TypeOrBounds = self.prefix
 
-  def NamedTermRef_apply(qual: TypeOrBounds, name: String) given Context: NamedTermRef =
-    Types.TermRef(qual, name.toTermName)
-
-  type NamedTypeRef = Types.NamedType
-
-  def matchNamedTypeRef(tpe: TypeOrBounds) given Context: Option[NamedTypeRef] = tpe match {
-    case tpe: Types.NamedType =>
-      tpe.designator match {
-        case name: Names.TypeName => Some(tpe)
-        case _ => None
-      }
-    case _ => None
-  }
-
-  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
 
   def matchSuperType(tpe: TypeOrBounds) given Context: Option[SuperType] = tpe match {

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

@@ -74,8 +74,6 @@ import scala.runtime.quoted.Unpickler
  *                   +- Type -------+- ConstantType
  *                                  +- TermRef
  *                                  +- TypeRef
- *                                  +- NamedTermRef
- *                                  +- NamedTypeRef
  *                                  +- SuperType
  *                                  +- Refinement
  *                                  +- AppliedType
@@ -330,7 +328,7 @@ trait CompilerInterface {
 
   def Ident_name(self: Ident) given (ctx: Context): String
 
-  def Ident_apply(tmref: NamedTermRef) given (ctx: Context): Term
+  def Ident_apply(tmref: TermRef) 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 */
@@ -933,10 +931,11 @@ trait CompilerInterface {
 
   def matchTermRef(tpe: TypeOrBounds) given (ctx: Context): Option[TermRef]
 
+  def TermRef_apply(qual: TypeOrBounds, name: String) given (ctx: Context): TermRef
+
   def TermRef_qualifier(self: TermRef) given (ctx: Context): TypeOrBounds
   def TermRef_name(self: TermRef) given (ctx: Context): String
 
-
   /** Type of a reference to a type symbol */
   type TypeRef <: Type
 
@@ -945,24 +944,6 @@ trait CompilerInterface {
   def TypeRef_qualifier(self: TypeRef) given (ctx: Context): TypeOrBounds
   def TypeRef_name(self: TypeRef) given Context: String
 
-  /** 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

@@ -71,8 +71,6 @@ package scala.tasty.reflect
  *                   +- Type -------+- ConstantType
  *                                  +- TermRef
  *                                  +- TypeRef
- *                                  +- NamedTermRef
- *                                  +- NamedTypeRef
  *                                  +- SuperType
  *                                  +- Refinement
  *                                  +- AppliedType
@@ -338,12 +336,6 @@ trait Core {
       /** Type of a reference to a type symbol */
       type TypeRef = internal.TypeRef
 
-      /** Type of a reference to a term */
-      type NamedTermRef = internal.NamedTermRef
-
-      /** Type of a reference to a type */
-      type NamedTypeRef = internal.NamedTypeRef
-
       /** Type of a `super` refernce */
       type SuperType = internal.SuperType
 

library/src/scala/tasty/reflect/Printers.scala

@@ -312,10 +312,6 @@ trait Printers
           this += "Type.TermRef(" += qual+= ", \"" += name += "\")"
         case Type.TypeRef(qual, name) =>
           this += "Type.TypeRef(" += qual += ", \"" += name += "\")"
-        case Type.NamedTermRef(qual, name) =>
-          this += "Type.NamedTermRef(" += qual += ", \"" += name += "\")"
-        case Type.NamedTypeRef(qual, name) =>
-          this += "Type.NamedTypeRef(" += qual += ", \"" += name += "\")"
         case Type.Refinement(parent, name, info) =>
           this += "Type.Refinement(" += parent += ", " += name += ", " += info += ")"
         case Type.AppliedType(tycon, args) =>
@@ -1555,35 +1551,14 @@ trait Printers
               this
           }
 
-        case Type.NamedTermRef(prefix, name) =>
-          prefix match {
-            case Type.ThisType(Types.EmptyPackage()) =>
-              this += highlightTypeDef(name)
-            case IsType(prefix) =>
-              printType(prefix)
-              if (name != "package")
-                this += "." += highlightTypeDef(name)
-              this
-            case NoPrefix() =>
-              this += highlightTypeDef(name)
-          }
-
-        case Type.NamedTypeRef(prefix, name) =>
-          prefix match {
-            case NoPrefix() | Type.ThisType(Types.EmptyPackage()) =>
-            case IsType(prefix) => printType(prefix) += "."
-          }
-          if (name.endsWith("$")) this += highlightTypeDef(name.stripSuffix("$")) += ".type"
-          else this += highlightTypeDef(name)
-
         case tpe @ Type.Refinement(_, _, _) =>
           printRefinement(tpe)
 
         case Type.AppliedType(tp, args) =>
           tp match {
             case Type.IsTypeLambda(tp) =>
               printType(tpe.dealias)
-            case Type.NamedTypeRef(Types.ScalaPackage(), "<repeated>") =>
+            case Type.TypeRef(Types.ScalaPackage(), "<repeated>") =>
               this += "_*"
             case _ =>
               printType(tp)
@@ -1620,7 +1595,7 @@ trait Printers
             case Type.IsTypeRef(tp) if !tp.typeSymbol.flags.is(Flags.Object) =>
               printFullClassName(tp)
               this += highlightTypeDef(".this")
-            case Type.NamedTypeRef(prefix, name) if name.endsWith("$") =>
+            case Type.TypeRef(prefix, name) if name.endsWith("$") =>
               prefix match {
                 case NoPrefix() | Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) =>
                 case _ =>
@@ -1707,9 +1682,9 @@ trait Printers
         val annots = definition.symbol.annots.filter {
           case Annotation(annot, _) =>
             annot.tpe match {
-              case Type.NamedTypeRef(Type.IsTermRef(prefix), _) if prefix.termSymbol.fullName == "scala.annotation.internal" => false
-              case Type.NamedTypeRef(Type.IsTypeRef(prefix), _) if prefix.typeSymbol.fullName == "scala.annotation.internal" => false
-              case Type.NamedTypeRef(Types.ScalaPackage(), "forceInline") => false
+              case Type.TypeRef(Type.IsTermRef(prefix), _) if prefix.termSymbol.fullName == "scala.annotation.internal" => false
+              case Type.TypeRef(Type.IsTypeRef(prefix), _) if prefix.typeSymbol.fullName == "scala.annotation.internal" => false
+              case Type.TypeRef(Types.ScalaPackage(), "forceInline") => false
               case _ => true
             }
           case x => throw new MatchError(x.showExtractors)
@@ -1893,30 +1868,30 @@ trait Printers
 
       object JavaLangObject {
         def unapply(tpe: Type) given (ctx: Context): Boolean = tpe match {
-          case Type.NamedTypeRef(Type.IsTermRef(prefix), "Object") => prefix.typeSymbol.fullName == "java.lang"
+          case Type.TypeRef(Type.IsTermRef(prefix), "Object") => prefix.typeSymbol.fullName == "java.lang"
           case _ => false
         }
       }
 
       object Sequence {
         def unapply(tpe: Type) given (ctx: Context): Option[Type] = tpe match {
-          case Type.AppliedType(Type.NamedTypeRef(Type.IsTermRef(prefix), "Seq"), IsType(tp) :: Nil) if prefix.termSymbol.fullName == "scala.collection" => Some(tp)
-          case Type.AppliedType(Type.NamedTypeRef(Type.IsTypeRef(prefix), "Seq"), IsType(tp) :: Nil) if prefix.typeSymbol.fullName == "scala.collection" => Some(tp)
+          case Type.AppliedType(Type.TypeRef(Type.IsTermRef(prefix), "Seq"), IsType(tp) :: Nil) if prefix.termSymbol.fullName == "scala.collection" => Some(tp)
+          case Type.AppliedType(Type.TypeRef(Type.IsTypeRef(prefix), "Seq"), IsType(tp) :: Nil) if prefix.typeSymbol.fullName == "scala.collection" => Some(tp)
           case _ => None
         }
       }
 
       object RepeatedAnnotation {
         def unapply(tpe: Type) given (ctx: Context): Boolean = tpe match {
-          case Type.NamedTypeRef(Type.IsTermRef(prefix), "Repeated") => prefix.termSymbol.fullName == "scala.annotation.internal"
-          case Type.NamedTypeRef(Type.IsTypeRef(prefix), "Repeated") => prefix.typeSymbol.fullName == "scala.annotation.internal"
+          case Type.TypeRef(Type.IsTermRef(prefix), "Repeated") => prefix.termSymbol.fullName == "scala.annotation.internal"
+          case Type.TypeRef(Type.IsTypeRef(prefix), "Repeated") => prefix.typeSymbol.fullName == "scala.annotation.internal"
           case _ => false
         }
       }
 
       object Repeated {
         def unapply(tpe: Type) given (ctx: Context): Option[Type] = tpe match {
-          case Type.AppliedType(Type.NamedTypeRef(ScalaPackage(), "<repeated>"), IsType(tp) :: Nil) => Some(tp)
+          case Type.AppliedType(Type.TypeRef(ScalaPackage(), "<repeated>"), IsType(tp) :: Nil) => Some(tp)
           case _ => None
         }
       }

library/src/scala/tasty/reflect/TreeOps.scala

@@ -250,7 +250,7 @@ trait TreeOps extends Core {
 
   /** Scala term identifier */
   object Ident {
-    def apply(tmref: NamedTermRef) given (ctx: Context): Term =
+    def apply(tmref: TermRef) given (ctx: Context): Term =
       internal.Ident_apply(tmref)
 
     def copy(original: Tree)(name: String) given (ctx: Context): Ident =

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -85,6 +85,8 @@ trait TypeOrBoundsOps extends Core {
     }
 
     object TermRef {
+      def apply(qual: TypeOrBounds, name: String) given (ctx: Context): TermRef =
+        internal.TermRef_apply(qual, name)
       def unapply(typeOrBounds: TypeOrBounds) given (ctx: Context): Option[(TypeOrBounds /* Type | NoPrefix */, String)] =
         internal.matchTermRef(typeOrBounds).map(x => (x.qualifier, x.name))
     }
@@ -100,31 +102,6 @@ trait TypeOrBoundsOps extends Core {
         internal.matchTypeRef(typeOrBounds).map(x => (x.qualifier, x.name))
     }
 
-    object IsNamedTermRef {
-      /** Matches any NamedTermRef and returns it */
-      def unapply(tpe: TypeOrBounds) given (ctx: Context): Option[NamedTermRef] =
-        internal.matchNamedTermRef(tpe)
-    }
-
-    object NamedTermRef {
-      // TODO should qual be a Type?
-      def apply(qual: TypeOrBounds, name: String) given (ctx: Context): NamedTermRef =
-        internal.NamedTermRef_apply(qual, name)
-      def unapply(typeOrBounds: TypeOrBounds) given (ctx: Context): Option[(TypeOrBounds /* Type | NoPrefix */, String)] =
-        internal.matchNamedTermRef(typeOrBounds).map(x => (x.qualifier, x.name))
-    }
-
-    object IsNameTypeRef {
-      /** Matches any TypeRef and returns it */
-      def unapply(tpe: TypeOrBounds) given (ctx: Context): Option[NamedTypeRef] =
-        internal.matchNamedTypeRef(tpe)
-    }
-
-    object NamedTypeRef {
-      def unapply(typeOrBounds: TypeOrBounds) given (ctx: Context): Option[(TypeOrBounds /* Type | NoPrefix */, String)] =
-        internal.matchNamedTypeRef(typeOrBounds).map(x => (x.qualifier, x.name))
-    }
-
     object IsSuperType {
       /** Matches any SuperType and returns it */
       def unapply(tpe: TypeOrBounds) given (ctx: Context): Option[SuperType] =
@@ -308,16 +285,6 @@ trait TypeOrBoundsOps extends Core {
     def name given (ctx: Context): String = internal.TypeRef_name(self)
   }
 
-  implicit class Type_NamedTermRefAPI(self: NamedTermRef) {
-    def name given (ctx: Context): String = internal.NamedTermRef_name(self)
-    def qualifier given (ctx: Context): TypeOrBounds /* Type | NoPrefix */ = internal.NamedTermRef_qualifier(self)
-  }
-
-  implicit class Type_NamedTypeRefAPI(self: NamedTypeRef) {
-    def name given (ctx: Context): String = internal.NamedTypeRef_name(self)
-    def qualifier given (ctx: Context): TypeOrBounds /* Type | NoPrefix */ = internal.NamedTypeRef_qualifier(self)
-  }
-
   implicit class Type_SuperTypeAPI(self: SuperType) {
     def thistpe given (ctx: Context): Type = internal.SuperType_thistpe(self)
     def supertpe given (ctx: Context): Type = internal.SuperType_supertpe(self)

tests/run-macros/i5941/macro_1.scala

@@ -102,8 +102,7 @@ object Iso {
     val cls = tpS.classSymbol.get
 
     val companion = tpS match {
-      case Type.TypeRef(prefix, name) => Type.NamedTermRef(prefix, name)
-      case Type.NamedTypeRef(prefix, name) => Type.NamedTermRef(prefix, name)
+      case Type.TypeRef(prefix, name) => Type.TermRef(prefix, name)
     }
 
     if (cls.caseFields.size != 1) {
@@ -131,7 +130,7 @@ object Iso {
     val tpS = typeOf[S]
 
     if (tpS.isSingleton) {
-      val ident = Ident(tpS.asInstanceOf[NamedTermRef]).seal.cast[S]
+      val ident = Ident(tpS.asInstanceOf[TermRef]).seal.cast[S]
       '{
         Iso[S, 1](Function.const($ident))(Function.const(1))
       }
@@ -145,8 +144,7 @@ object Iso {
       }
 
       val companion = tpS match {
-        case Type.TypeRef(prefix, name) => Type.NamedTermRef(prefix, name)
-        case Type.NamedTypeRef(prefix, name) => Type.NamedTermRef(prefix, name)
+        case Type.TypeRef(prefix, name) => Type.TermRef(prefix, name)
       }
 
       val obj = Select.overloaded(Ident(companion), "apply", Nil, Nil).seal.cast[S]