Add Tasty.SyntheticBounds

To represent dotty TypeTrees containing type bounds

Author: nicolasstucki

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

@@ -522,7 +522,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
     object Synthetic extends SyntheticExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Boolean = x match {
-        case Trees.TypeTree() => true
+        case x @ Trees.TypeTree() => !x.tpe.isInstanceOf[Types.TypeBounds]
         case _ => false
       }
     }
@@ -594,9 +594,11 @@ object TastyImpl extends scala.tasty.Tasty {
 
   // ----- TypeBoundsTrees ------------------------------------------------
 
-  type TypeBoundsTree = tpd.TypeBoundsTree
+  type TypeBoundsTree = tpd.Tree
 
-  def TypeBoundsTreeDeco(x: TypeBoundsTree): AbstractTypeBoundsTree = ???
+  def TypeBoundsTreeDeco(x: TypeBoundsTree): AbstractTypeBoundsTree = new AbstractTypeBoundsTree {
+    def tpe: TypeBounds = x.tpe.asInstanceOf[Types.TypeBounds]
+  }
 
   def typeBoundsTreeClassTag: ClassTag[TypeBoundsTree] = implicitly[ClassTag[TypeBoundsTree]]
 
@@ -607,6 +609,13 @@ object TastyImpl extends scala.tasty.Tasty {
     }
   }
 
+  object SyntheticBounds extends SyntheticBoundsExtractor {
+    def unapply(x: TypeBoundsTree)(implicit ctx: Context): Boolean = x match {
+      case x @ Trees.TypeTree() => x.tpe.isInstanceOf[Types.TypeBounds]
+      case _ => false
+    }
+  }
+
   // ===== Types ====================================================
 
   type TypeOrBounds = Types.Type

library/src/scala/tasty/Tasty.scala

@@ -442,6 +442,11 @@ abstract class Tasty { tasty =>
     def unapply(x: TypeBoundsTree)(implicit ctx: Context): Option[(TypeTree, TypeTree)]
   }
 
+  val SyntheticBounds: SyntheticBoundsExtractor
+  abstract class SyntheticBoundsExtractor {
+    def unapply(x: TypeBoundsTree)(implicit ctx: Context): Boolean
+  }
+
   // ===== Types ====================================================
 
   type TypeOrBounds

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

@@ -106,6 +106,8 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         this += "TypeTree.Annotated(" += arg += ", " += annot += ")"
       case TypeBoundsTree(lo, hi) =>
         this += "TypeBoundsTree(" += lo += ", " += hi += ")"
+      case SyntheticBounds() =>
+        this += s"SyntheticBounds()"
     }
 
     def visitCaseDef(x: CaseDef): Buffer = {
@@ -182,7 +184,8 @@ class ShowExtractors[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case Type.PolyType(argNames, argBounds, resType) =>
         this += "Type.PolyType(" ++= argNames += ", " ++= argBounds += ", " += resType += ")"
       case Type.TypeLambda(argNames, argBounds, resType) =>
-        this += "Type.TypeLambda(" ++= argNames += ", " ++= argBounds += ", " += resType += ")"
+        // resType is not printed to avoid cycles
+        this += "Type.TypeLambda(" ++= argNames += ", " ++= argBounds += ", _)"
       case TypeBounds(lo, hi) =>
         this += "TypeBounds(" += lo += ", " += hi += ")"
       case NoPrefix() =>

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

@@ -434,9 +434,11 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
               this += " <: "
               printTypeTree(hi)
           }
-        case tpt@TypeTree() =>
+        case rhs @ SyntheticBounds() =>
+          printTypeOrBound(rhs.tpe)
+        case rhs @ TypeTree() =>
           this += " = "
-          printTypeTree(tpt)
+          printTypeTree(rhs)
       }
     }
 
@@ -538,6 +540,8 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         printTypeTree(lo)
         this += " <: "
         printTypeTree(hi)
+      case tpt @ SyntheticBounds() =>
+        printTypeOrBound(tpt.tpe)
       case tpt@Type() =>
         printType(tpt)
     }

tests/pos/i2104.decompiled

@@ -0,0 +1,50 @@
+/** Decompiled from out/posTestFromTasty/pos/i2104/Cons.class */
+class Cons[H, T]() extends java.lang.Object
+object Cons {
+  def apply[H, T](h: H, t: T): Cons[H, T] = scala.Predef.???
+  def unapply[H, T](t: Cons[H, T]): scala.Option[<empty>.Pair[H, T]] = scala.Predef.???
+}/** Decompiled from out/posTestFromTasty/pos/i2104/Pair.class */
+case class Pair[A, B](_1: A, _2: B) {
+  def copy[A >: scala.Nothing <: scala.Any, B >: scala.Nothing <: scala.Any](_1: A, _2: B): Pair[A, B] = new Pair[A, B](_1, _2)
+  def copy$default$1[A >: scala.Nothing <: scala.Any, B >: scala.Nothing <: scala.Any]: Pair.A = (Pair._1: Pair._1)
+  def copy$default$2[A >: scala.Nothing <: scala.Any, B >: scala.Nothing <: scala.Any]: Pair.B = (Pair._2: Pair._2)
+  override def hashCode(): scala.Int = {
+    var acc: scala.Int = 2479866
+    acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Pair._1))
+    acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Pair._2))
+    scala.runtime.Statics.finalizeHash(acc, 2)
+  }
+  override def equals(x$0: scala.Any): scala.Boolean = this.eq(x$0.asInstanceOf[java.lang.Object]).||(x$0 match {
+    case x$0: Pair[Pair.A, Pair.B] =>
+      this._1.==(x$0._1).&&(this._2.==(x$0._2))
+    case _ =>
+      false
+  })
+  override def toString(): java.lang.String = scala.runtime.ScalaRunTime._toString(this)
+  override def canEqual(that: scala.Any): scala.Boolean = that.isInstanceOf[Pair[Pair.A, Pair.B]]
+  override def productArity: scala.Int = 2
+  override def productPrefix: java.lang.String = "Pair"
+  override def productElement(n: scala.Int): scala.Any = n match {
+    case 0 =>
+      this._1
+    case 1 =>
+      this._2
+    case _ =>
+      throw new java.lang.IndexOutOfBoundsException(n.toString())
+  }
+}
+object Pair extends scala.AnyRef {
+  def apply[A >: scala.Nothing <: scala.Any, B >: scala.Nothing <: scala.Any](_1: A, _2: B): Pair[A, B] = new Pair[A, B](_1, _2)
+  def unapply[A >: scala.Nothing <: scala.Any, B >: scala.Nothing <: scala.Any](x$1: Pair[A, B]): Pair[A, B] = x$1
+}/** Decompiled from out/posTestFromTasty/pos/i2104/Test.class */
+object Test {
+  def main(args: scala.Array[scala.Predef.String]): scala.Unit = {
+    <empty>.Cons.apply[scala.Option[scala.Int], scala.None](scala.Option.apply[scala.Int](1), scala.None) match {
+      case <empty>.Cons.unapply[scala.Option[scala.Int], scala.None](, scala.None) =>
+        {
+          (i: scala.Int)
+          dotty.DottyPredef.assert(i.==(1))
+        }
+    }
+  }
+}

tests/pos/tasty/definitions.scala

@@ -88,11 +88,16 @@ object definitions {
     case ByName(tpt: TypeTree)
   }
 
-  /** Trees denoting type bounds*/
+  /** Trees denoting type bounds */
   case class TypeBoundsTree(loBound: TypeTree, hiBound: TypeTree) extends Tree {
     def tpe: Type.TypeBounds = ???
   }
 
+  /** Trees denoting type infered bounds */
+  case class SyntheticBounds() extends Tree {
+    def tpe: Type.TypeBounds = ???
+  }
+
   /** Trees denoting patterns */
   enum Pattern extends Positioned {
     def tpe: Type = ???

tests/run/tasty-extractors-owners.check

@@ -17,11 +17,11 @@ baz2
 ValDef("foo2", TypeTree.Synthetic(), None)
 
 <init>
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", TypeTree.Synthetic()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", SyntheticBounds()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))
 
 b
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", TypeTree.Synthetic()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", SyntheticBounds()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))
 
 b2
-ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", TypeTree.Synthetic()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))
+ClassDef("A", DefDef("<init>", Nil, List(Nil), TypeTree.Synthetic(), None), List(Term.Apply(Term.Select(Term.New(TypeTree.Synthetic()), "<init>", Some(Signature(Nil, java.lang.Object))), Nil)), None, List(TypeDef("B", SyntheticBounds()), DefDef("b", Nil, Nil, TypeTree.Synthetic(), None), ValDef("b2", TypeTree.Synthetic(), None)))