Rename SyntheticBounds to WildcardTypeTree

Author: nicolasstucki

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

@@ -159,7 +159,7 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
     }
   }
 
-  object SyntheticBounds extends SyntheticBoundsExtractor {
+  object WildcardTypeTree extends WildcardTypeTreeExtractor {
     def unapply(x: TypeOrBoundsTree)(implicit ctx: Context): Boolean = x match {
       case x @ Trees.TypeTree() => x.tpe.isInstanceOf[Types.TypeBounds]
       case Trees.Ident(nme.WILDCARD) => x.tpe.isInstanceOf[Types.TypeBounds]

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

@@ -52,7 +52,7 @@ package scala.tasty.reflect
  *                         |               +- Bind
  *                         |
  *                         +- TypeBoundsTree
- *                         +- SyntheticBounds
+ *                         +- WildcardTypeTree
  *
  *  +- CaseDef
  *  +- TypeCaseDef
@@ -311,6 +311,9 @@ trait Core {
     /** Type tree representing a type bound written in the source */
     type TypeBoundsTree <: TypeOrBoundsTree
 
+    /** Type tree representing wildcard type bounds written in the source */
+    type WildcardType <: TypeOrBoundsTree
+
   /** Type or bounds */
   type TypeOrBounds <: AnyRef
 

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

@@ -190,8 +190,8 @@ trait Printers
           this += "TypeTree.Block(" ++= aliases += ", " += tpt += ")"
         case TypeBoundsTree(lo, hi) =>
           this += "TypeBoundsTree(" += lo += ", " += hi += ")"
-        case SyntheticBounds() =>
-          this += s"SyntheticBounds()"
+        case WildcardTypeTree() =>
+          this += s"WildcardTypeTree()"
         case TypeTree.MatchType(bound, selector, cases) =>
           this += "TypeTree.MatchType(" += bound += ", " += selector += ", " ++= cases += ")"
       }
@@ -996,7 +996,7 @@ trait Printers
         this += arg.name
         arg.rhs match {
           case IsTypeBoundsTree(rhs) => printBoundsTree(rhs)
-          case rhs @ SyntheticBounds() =>
+          case rhs @ WildcardTypeTree() =>
             printTypeOrBound(rhs.tpe)
           case rhs @ TypeTree.TypeLambdaTree(tparams, body) =>
             def printParam(t: TypeOrBoundsTree): Unit = t match {
@@ -1184,7 +1184,7 @@ trait Printers
           printTypeTree(lo)
           this += " <: "
           printTypeTree(hi)
-        case tpt @ SyntheticBounds() =>
+        case tpt @ WildcardTypeTree() =>
           printTypeOrBound(tpt.tpe)
         case IsTypeTree(tpt) =>
           printTypeTree(tpt)

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -105,7 +105,7 @@ trait TreeUtils
       case TypeTree.MatchType(boundopt, selector, cases) =>
         foldTypeCaseDefs(foldTypeTree(boundopt.fold(x)(foldTypeTree(x, _)), selector), cases)
       case TypeBoundsTree(lo, hi) => foldTypeTree(foldTypeTree(x, lo), hi)
-      case SyntheticBounds() => x
+      case WildcardTypeTree() => x
     }
 
     def foldOverCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X = tree match {

library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala

@@ -125,10 +125,10 @@ trait TypeOrBoundsTreeOps extends Core {
     def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Option[(TypeTree, TypeTree)]
   }
 
-  /** TypeBoundsTree containing an inferred type bounds */
-  val SyntheticBounds: SyntheticBoundsExtractor
-  abstract class SyntheticBoundsExtractor {
-    /** Matches a TypeBoundsTree containing inferred type bounds */
+  /** TypeBoundsTree containing wildcard type bounds */
+  val WildcardTypeTree: WildcardTypeTreeExtractor
+  abstract class WildcardTypeTreeExtractor {
+    /** Matches a TypeBoundsTree containing wildcard type bounds */
     def unapply(typeOrBoundsTree: TypeOrBoundsTree)(implicit ctx: Context): Boolean
   }