Rename MaybeType to TypeOrBounds

Author: nicolasstucki

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

@@ -186,7 +186,7 @@ object TastyImpl extends scala.tasty.Tasty {
   def typeDefClassTag: ClassTag[TypeDef] = implicitly[ClassTag[TypeDef]]
 
   val TypeDef: TypeDefExtractor = new TypeDefExtractor {
-    def unapply(x: TypeDef)(implicit ctx: Context): Option[(String, MaybeTypeTree /* TypeTree | TypeBoundsTree */)] = x match {
+    def unapply(x: TypeDef)(implicit ctx: Context): Option[(String, TypeOrBoundsTree /* TypeTree | TypeBoundsTree */)] = x match {
       case x: tpd.TypeDef @unchecked if !x.symbol.isClass => Some((x.name.toString, x.rhs))
       case _ => None
     }
@@ -446,11 +446,11 @@ object TastyImpl extends scala.tasty.Tasty {
     }
   }
 
-  // ----- MaybeTypeTree ------------------------------------------------
+  // ----- TypeOrBoundsTree ------------------------------------------------
 
-  type MaybeTypeTree = tpd.Tree
+  type TypeOrBoundsTree = tpd.Tree
 
-  implicit def MaybeTypeTreeDeco(x: MaybeTypeTree): AbstractMaybeTypeTree = new AbstractMaybeTypeTree {
+  implicit def TypeOrBoundsTreeDeco(x: TypeOrBoundsTree): AbstractTypeOrBoundsTree = new AbstractTypeOrBoundsTree {
     def tpe(implicit ctx: Context): Type = x.tpe.stripTypeVar
   }
 
@@ -552,7 +552,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   // ===== Types ====================================================
 
-  type MaybeType = Types.Type
+  type TypeOrBounds = Types.Type
 
   // ----- Types ----------------------------------------------------
 
@@ -568,7 +568,7 @@ object TastyImpl extends scala.tasty.Tasty {
   }
 
   val SymRef: SymRefExtractor = new SymRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Definition, MaybeType /* Type | NoPrefix */)] = x  match {
+    def unapply(x: Type)(implicit ctx: Context): Option[(Definition, TypeOrBounds /* Type | NoPrefix */)] = x  match {
       case tp: Types.NamedType =>
         tp.designator match {
           case sym: Symbol => Some((FromSymbol.definition(sym), tp.prefix))
@@ -579,7 +579,7 @@ object TastyImpl extends scala.tasty.Tasty {
   }
 
   val NameRef: NameRefExtractor = new NameRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(String, MaybeType /* Type | NoPrefix */)] = x match {
+    def unapply(x: Type)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)] = x match {
       case tp: Types.NamedType =>
         tp.designator match {
           case name: Names.Name => Some(name.toString, tp.prefix)
@@ -597,14 +597,14 @@ object TastyImpl extends scala.tasty.Tasty {
   }
 
   val Refinement: RefinementExtractor = new RefinementExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Type, String, MaybeType /* Type | TypeBounds */)] = x match {
+    def unapply(x: Type)(implicit ctx: Context): Option[(Type, String, TypeOrBounds /* Type | TypeBounds */)] = x match {
       case Types.RefinedType(parent, name, info) => Some(parent, name.toString, info)
       case _ => None
     }
   }
 
   val AppliedType: AppliedTypeExtractor = new AppliedTypeExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Type, List[MaybeType /* Type | TypeBounds */])] = x match {
+    def unapply(x: Type)(implicit ctx: Context): Option[(Type, List[TypeOrBounds /* Type | TypeBounds */])] = x match {
       case Types.AppliedType(tycon, args) => Some((tycon.stripTypeVar, args.map(_.stripTypeVar)))
       case _ => None
     }
@@ -639,10 +639,10 @@ object TastyImpl extends scala.tasty.Tasty {
   }
 
   val ParamRef: ParamRefExtractor = new ParamRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(LambdaType[MaybeType], Int)] = x match {
+    def unapply(x: Type)(implicit ctx: Context): Option[(LambdaType[TypeOrBounds], Int)] = x match {
       case Types.TypeParamRef(binder, idx) =>
         Some((
-          binder.asInstanceOf[LambdaType[MaybeType]], // Cast to tpd
+          binder.asInstanceOf[LambdaType[TypeOrBounds]], // Cast to tpd
           idx))
       case _ => None
     }
@@ -675,7 +675,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   // ----- Methodic Types -------------------------------------------
 
-  type LambdaType[ParamInfo <: MaybeType] = Types.LambdaType { type PInfo = ParamInfo }
+  type LambdaType[ParamInfo <: TypeOrBounds] = Types.LambdaType { type PInfo = ParamInfo }
 
   type MethodType = Types.MethodType
 

library/src/scala/tasty/Tasty.scala

@@ -146,7 +146,7 @@ abstract class Tasty {
 
   val TypeDef: TypeDefExtractor
   abstract class TypeDefExtractor {
-    def unapply(x: TypeDef)(implicit ctx: Context): Option[(String, MaybeTypeTree /* TypeTree | TypeBoundsTree */)]
+    def unapply(x: TypeDef)(implicit ctx: Context): Option[(String, TypeOrBoundsTree /* TypeTree | TypeBoundsTree */)]
   }
 
   // PackageDef
@@ -332,17 +332,17 @@ abstract class Tasty {
 
   // ----- TypeTrees ------------------------------------------------
 
-  type MaybeTypeTree
+  type TypeOrBoundsTree
 
-  trait AbstractMaybeTypeTree {
-    def tpe(implicit ctx: Context): MaybeType
+  trait AbstractTypeOrBoundsTree {
+    def tpe(implicit ctx: Context): TypeOrBounds
   }
-  implicit def MaybeTypeTreeDeco(x: MaybeTypeTree): AbstractMaybeTypeTree
+  implicit def TypeOrBoundsTreeDeco(x: TypeOrBoundsTree): AbstractTypeOrBoundsTree
 
 
   // ----- TypeTrees ------------------------------------------------
 
-  type TypeTree <: MaybeTypeTree
+  type TypeTree <: TypeOrBoundsTree
 
   trait AbstractTypeTree extends Typed with Positioned
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree
@@ -401,7 +401,7 @@ abstract class Tasty {
 
   // ----- TypeBoundsTrees ------------------------------------------------
 
-  type TypeBoundsTree <: MaybeTypeTree
+  type TypeBoundsTree <: TypeOrBoundsTree
 
   trait AbstractTypeBoundsTree {
     def tpe: TypeBounds
@@ -417,15 +417,15 @@ abstract class Tasty {
 
   // ===== Types ====================================================
 
-  type MaybeType
+  type TypeOrBounds
 
   trait Typed {
     def tpe(implicit ctx: Context): Type
   }
 
   // ----- Types ----------------------------------------------------
 
-  type Type <: MaybeType
+  type Type <: TypeOrBounds
 
   implicit def typeClassTag: ClassTag[Type]
 
@@ -436,12 +436,12 @@ abstract class Tasty {
 
   val SymRef: SymRefExtractor
   abstract class SymRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Definition, MaybeType /* Type | NoPrefix */)]
+    def unapply(x: Type)(implicit ctx: Context): Option[(Definition, TypeOrBounds /* Type | NoPrefix */)]
   }
 
   val NameRef: NameRefExtractor
   abstract class NameRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(String, MaybeType /* Type | NoPrefix */)]
+    def unapply(x: Type)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)]
   }
 
   val SuperType: SuperTypeExtractor
@@ -451,12 +451,12 @@ abstract class Tasty {
 
   val Refinement: RefinementExtractor
   abstract class RefinementExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Type, String, MaybeType /* Type | TypeBounds */)]
+    def unapply(x: Type)(implicit ctx: Context): Option[(Type, String, TypeOrBounds /* Type | TypeBounds */)]
   }
 
   val AppliedType: AppliedTypeExtractor
   abstract class AppliedTypeExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(Type, List[MaybeType /* Type | TypeBounds */])]
+    def unapply(x: Type)(implicit ctx: Context): Option[(Type, List[TypeOrBounds /* Type | TypeBounds */])]
   }
 
   val AnnotatedType: AnnotatedTypeExtractor
@@ -481,7 +481,7 @@ abstract class Tasty {
 
   val ParamRef: ParamRefExtractor
   abstract class ParamRefExtractor {
-    def unapply(x: Type)(implicit ctx: Context): Option[(LambdaType[MaybeType], Int)]
+    def unapply(x: Type)(implicit ctx: Context): Option[(LambdaType[TypeOrBounds], Int)]
   }
 
   val ThisType: ThisTypeExtractor
@@ -503,7 +503,7 @@ abstract class Tasty {
 
   // ----- Methodic Types -------------------------------------------
 
-  type LambdaType[ParamInfo <: MaybeType] <: Type
+  type LambdaType[ParamInfo <: TypeOrBounds] <: Type
 
   type MethodType <: LambdaType[Type]
 
@@ -540,7 +540,7 @@ abstract class Tasty {
 
   // ----- TypeBounds -----------------------------------------------
 
-  type TypeBounds <: MaybeType
+  type TypeBounds <: TypeOrBounds
 
   implicit def typeBoundsClassTag: ClassTag[TypeBounds]
 
@@ -551,7 +551,7 @@ abstract class Tasty {
 
   // ----- NoPrefix -------------------------------------------------
 
-  type NoPrefix <: MaybeType
+  type NoPrefix <: TypeOrBounds
 
   implicit def noPrefixClassTag: ClassTag[NoPrefix]
 

library/src/scala/tasty/util/TastyPrinter.scala

@@ -11,13 +11,13 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     buff.toString()
   }
 
-  def stringOfTypeTree(tree: MaybeTypeTree)(implicit ctx: Context): String = {
+  def stringOfTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): String = {
     implicit val buff: StringBuilder = new StringBuilder
     visitTypeTree(tree)
     buff.toString()
   }
 
-  def stringOfType(tpe: MaybeType)(implicit ctx: Context): String = {
+  def stringOfType(tpe: TypeOrBounds)(implicit ctx: Context): String = {
     implicit val buff: StringBuilder = new StringBuilder
     visitType(tpe)
     buff.toString()
@@ -290,7 +290,7 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     }
   }
 
-  private def visitTypeTree(x: MaybeTypeTree)(implicit buff: StringBuilder, ctx: Context): Unit = {
+  private def visitTypeTree(x: TypeOrBoundsTree)(implicit buff: StringBuilder, ctx: Context): Unit = {
     x match {
       case Synthetic() =>
         buff append "Synthetic()"
@@ -462,7 +462,7 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
     case StringConstant(value) => buff append "String(" append value append ")"
   }
 
-  private def visitType(x: MaybeType)(implicit buff: StringBuilder, ctx: Context): Unit = x match {
+  private def visitType(x: TypeOrBounds)(implicit buff: StringBuilder, ctx: Context): Unit = x match {
     case ConstantType(value) =>
       buff append "ConstantType("
       visitConstant(value)
@@ -568,12 +568,12 @@ class TastyPrinter[T <: Tasty with Singleton](val tasty: T) {
       buff append "NoPrefix"
   }
 
-  private def visitTypes(list: List[MaybeType])(implicit buff: StringBuilder, ctx: Context): Unit = {
+  private def visitTypes(list: List[TypeOrBounds])(implicit buff: StringBuilder, ctx: Context): Unit = {
     list match {
       case x0 :: xs =>
         buff append "List("
         visitType(x0)
-        def visitNext(xs: List[MaybeType]): Unit = xs match {
+        def visitNext(xs: List[TypeOrBounds]): Unit = xs match {
           case y :: ys =>
             buff append ", "
             visitType(y)

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

@@ -7,13 +7,13 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
 
   // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
   def foldTree(x: X, tree: Tree)(implicit ctx: Context): X
-  def foldTypeTree(x: X, tree: MaybeTypeTree)(implicit ctx: Context): X
+  def foldTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X
   def foldCaseDef(x: X, tree: CaseDef)(implicit ctx: Context): X
   def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X
   def foldParent(x: X, tree: Parent)(implicit ctx: Context): X
 
   def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X = (x /: trees)(foldTree)
-  def foldTypeTrees(x: X, trees: Iterable[MaybeTypeTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
+  def foldTypeTrees(x: X, trees: Iterable[TypeOrBoundsTree])(implicit ctx: Context): X = (x /: trees)(foldTypeTree)
   def foldCaseDefs(x: X, trees: Iterable[CaseDef])(implicit ctx: Context): X = (x /: trees)(foldCaseDef)
   def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X = (x /: trees)(foldPattern)
   def foldParents(x: X, trees: Iterable[Parent])(implicit ctx: Context): X = (x /: trees)(foldParent)
@@ -80,7 +80,7 @@ abstract class TreeAccumulator[X, T <: Tasty with Singleton](val tasty: T) {
     }
   }
 
-  def foldOverTypeTree(x: X, tree: MaybeTypeTree)(implicit ctx: Context): X = tree match {
+  def foldOverTypeTree(x: X, tree: TypeOrBoundsTree)(implicit ctx: Context): X = tree match {
     case Synthetic() => x
     case TypeIdent(_) => x
     case TypeSelect(qualifier, _) => foldTree(x, qualifier)

library/src/scala/tasty/util/TreeTraverser.scala

@@ -6,19 +6,19 @@ abstract class TreeTraverser[T <: Tasty with Singleton](tasty0: T) extends TreeA
   import tasty._
 
   def traverseTree(tree: Tree)(implicit ctx: Context): Unit = traverseTreeChildren(tree)
-  def traverseTypeTree(tree: MaybeTypeTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree)
+  def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = traverseTypeTreeChildren(tree)
   def traverseCaseDef(tree: CaseDef)(implicit ctx: Context): Unit = traverseCaseDefChildren(tree)
   def traversePattern(tree: Pattern)(implicit ctx: Context): Unit = traversePatternChildren(tree)
   def traverseParent(tree: Parent)(implicit ctx: Context): Unit = traverseParentChildren(tree)
 
   def foldTree(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverseTree(tree)
-  def foldTypeTree(x: Unit, tree: MaybeTypeTree)(implicit ctx: Context) = traverseTypeTree(tree)
+  def foldTypeTree(x: Unit, tree: TypeOrBoundsTree)(implicit ctx: Context) = traverseTypeTree(tree)
   def foldCaseDef(x: Unit, tree: CaseDef)(implicit ctx: Context) = traverseCaseDef(tree)
   def foldPattern(x: Unit, tree: Pattern)(implicit ctx: Context) = traversePattern(tree)
   def foldParent(x: Unit, tree: Parent)(implicit ctx: Context) = traverseParent(tree)
 
   protected def traverseTreeChildren(tree: Tree)(implicit ctx: Context): Unit = foldOverTree((), tree)
-  protected def traverseTypeTreeChildren(tree: MaybeTypeTree)(implicit ctx: Context): Unit = foldOverTypeTree((), tree)
+  protected def traverseTypeTreeChildren(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = foldOverTypeTree((), tree)
   protected def traverseCaseDefChildren(tree: CaseDef)(implicit ctx: Context): Unit = foldOverCaseDef((), tree)
   protected def traversePatternChildren(tree: Pattern)(implicit ctx: Context): Unit = foldOverPattern((), tree)
   protected def traverseParentChildren(tree: Parent)(implicit ctx: Context): Unit = foldOverParent((), tree)

tests/run/tasty-extractors-3/quoted_1.scala

@@ -17,7 +17,7 @@ object Macros {
 
     val buff = new StringBuilder
     val traverser = new TreeTraverser(u.tasty) {
-      override def traverseTypeTree(tree: MaybeTypeTree)(implicit ctx: Context): Unit = {
+      override def traverseTypeTree(tree: TypeOrBoundsTree)(implicit ctx: Context): Unit = {
         buff.append(printer.stringOfType(tree.tpe))
         buff.append("\n\n")
         traverseTypeTreeChildren(tree)

tests/run/tasty-indexed-map/quoted_1.scala

@@ -31,11 +31,11 @@ object Index {
     import u._
     import u.tasty._
 
-    def name(tp: MaybeType): String = tp match {
+    def name(tp: TypeOrBounds): String = tp match {
       case ConstantType(StringConstant(str)) => str
     }
 
-    def names(tp: MaybeType): List[String] = tp match {
+    def names(tp: TypeOrBounds): List[String] = tp match {
       case AppliedType(_, x1 :: x2 :: Nil) => name(x1) :: names(x2)
       case _ => Nil
     }

tests/run/tasty-macro-assert/quoted_1.scala

@@ -22,7 +22,7 @@ object Asserts {
 
     val tree = cond.toTasty
 
-    def isOps(tpe: MaybeType): Boolean = tpe match {
+    def isOps(tpe: TypeOrBounds): Boolean = tpe match {
       case SymRef(DefDef("Ops", _, _, _, _), _) => true // TODO check that the parent is Asserts
       case _ => false
     }