Split TypeSelect into TypeSelect and TermSelect

To make it easier to consume the API.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/TastyImpl.scala

@@ -554,9 +554,16 @@ object TastyImpl extends scala.tasty.Tasty {
       }
     }
 
+    object TermSelect extends TermSelectExtractor {
+      def unapply(x: TypeTree)(implicit ctx: Context): Option[(Term, String)] = x match {
+        case x: tpd.Select @unchecked if x.isType && x.qualifier.isTerm => Some(x.qualifier, x.name.toString)
+        case _ => None
+      }
+    }
+
     object TypeSelect extends TypeSelectExtractor {
-      def unapply(x: TypeTree)(implicit ctx: Context): Option[(Parent, String)] = x match {
-        case x: tpd.Select @unchecked if x.isType => Some(x.qualifier, x.name.toString)
+      def unapply(x: TypeTree)(implicit ctx: Context): Option[(TypeTree, String)] = x match {
+        case x: tpd.Select @unchecked if x.isType && x.qualifier.isType => Some(x.qualifier, x.name.toString)
         case _ => None
       }
     }

library/src/scala/tasty/Tasty.scala

@@ -433,9 +433,14 @@ abstract class Tasty { tasty =>
       def unapply(x: TypeTree)(implicit ctx: Context): Option[String]
     }
 
+    val TermSelect: TermSelectExtractor
+    abstract class TermSelectExtractor {
+      def unapply(x: TypeTree)(implicit ctx: Context): Option[(Term, String)]
+    }
+
     val TypeSelect: TypeSelectExtractor
     abstract class TypeSelectExtractor {
-      def unapply(x: TypeTree)(implicit ctx: Context): Option[(Parent, String)]
+      def unapply(x: TypeTree)(implicit ctx: Context): Option[(TypeTree, String)]
     }
 
     val Singleton: SingletonExtractor

library/src/scala/tasty/util/ShowExtractors.scala

@@ -94,13 +94,10 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "TypeTree.Synthetic()"
       case TypeTree.TypeIdent(name) =>
         this += "TypeTree.TypeIdent(\"" += name += "\")"
+      case TypeTree.TermSelect(qualifier, name) =>
+        this += "TypeTree.TermSelect(" += qualifier += ", \"" += name += "\")"
       case TypeTree.TypeSelect(qualifier, name) =>
-        this += "TypeTree.TypeSelect("
-        qualifier match {
-          case qualifier @ Term() => this += qualifier
-          case qualifier @ TypeTree() => this += qualifier
-        }
-        this += ", \"" += name += "\")"
+        this += "TypeTree.TypeSelect(" += qualifier += ", \"" += name += "\")"
       case TypeTree.Singleton(ref) =>
         this += "TypeTree.Singleton(" += ref += ")"
       case TypeTree.And(left, right) =>

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -85,7 +85,7 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
         val parents1 = parents.filter {
           case Term.Apply(Term.Select(Term.New(tpt), _, _), _) => !Types.JavaLangObject.unapply(tpt.tpe)
-          case TypeTree.TypeSelect(Term.Select(Term.Ident("_root_"), "scala", _), "Product") => false
+          case TypeTree.TermSelect(Term.Select(Term.Ident("_root_"), "scala", _), "Product") => false
           case _ => true
         }
         if (parents1.nonEmpty) {
@@ -701,11 +701,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case TypeTree.TypeIdent(name) =>
         printType(tree.tpe)
 
+      case TypeTree.TermSelect(qual, name) =>
+        printTree(qual) += "." += name
+
       case TypeTree.TypeSelect(qual, name) =>
-        qual match {
-          case qual @ Term() => printTree(qual) += "." += name
-          case qual @ TypeTree() => printTypeTree(qual) += "#" += name
-        }
+        printTypeTree(qual) += "#" += name
 
       case TypeTree.Singleton(ref) =>
         printTree(ref)

library/src/scala/tasty/util/TreeAccumulator.scala

@@ -81,8 +81,8 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
   def foldOverTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X = tree match {
     case TypeTree.Synthetic() => x
     case TypeTree.TypeIdent(_) => x
-    case TypeTree.TypeSelect(qualifier @ Term(), _) => foldTree(x, qualifier)
-    case TypeTree.TypeSelect(qualifier @ TypeTree(), _) => foldTypeTree(x, qualifier)
+    case TypeTree.TermSelect(qualifier, _) => foldTree(x, qualifier)
+    case TypeTree.TypeSelect(qualifier, _) => foldTypeTree(x, qualifier)
     case TypeTree.Singleton(ref) => foldTree(x, ref)
     case TypeTree.And(left, right) => foldTypeTree(foldTypeTree(x, left), right)
     case TypeTree.Or(left, right) => foldTypeTree(foldTypeTree(x, left), right)

tests/pos/tasty/definitions.scala

@@ -92,7 +92,8 @@ object definitions {
     def tpe: Type = ???
     case Synthetic()
     case Ident(name: String, override val tpe: Type)
-    case Select(prefix: Term | TypeTree, name: String)
+    case TermSelect(prefix: Term, name: String)
+    case TypeSelect(prefix: TypeTree, name: String)
     case Singleton(ref: Term)
     case Refined(underlying: TypeTree, refinements: List[Definition])
     case Applied(tycon: TypeTree, args: List[TypeTree | TypeBoundsTree])