Update TASTy Reflect to summon and given

Author: nicolasstucki

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

@@ -1885,62 +1885,62 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   // IMPLICITS
   //
 
-  type ImplicitSearchResult = Tree
+  type GivenSearchResult = Tree
 
-  def searchImplicit(tpe: Type)(given ctx: Context): ImplicitSearchResult =
+  def searchGiven(tpe: Type)(given ctx: Context): GivenSearchResult =
     ctx.typer.inferImplicitArg(tpe, rootPosition.span)
 
-  type ImplicitSearchSuccess = Tree
-  def isInstanceOfImplicitSearchSuccess(given ctx: Context): IsInstanceOf[ImplicitSearchSuccess] = new {
-    def runtimeClass: Class[?] = classOf[ImplicitSearchSuccess]
-    override def unapply(x: Any): Option[ImplicitSearchSuccess] = x match
+  type GivenSearchSuccess = Tree
+  def isInstanceOfGivenSearchSuccess(given ctx: Context): IsInstanceOf[GivenSearchSuccess] = new {
+    def runtimeClass: Class[?] = classOf[GivenSearchSuccess]
+    override def unapply(x: Any): Option[GivenSearchSuccess] = x match
       case x: Tree =>
         x.tpe match
           case _: SearchFailureType => None
           case _ => Some(x)
       case _ => None
   }
-  def ImplicitSearchSuccess_tree(self: ImplicitSearchSuccess)(given Context): Term = self
+  def GivenSearchSuccess_tree(self: GivenSearchSuccess)(given Context): Term = self
 
-  type ImplicitSearchFailure = Tree
-  def isInstanceOfImplicitSearchFailure(given ctx: Context): IsInstanceOf[ImplicitSearchFailure] = new {
-    def runtimeClass: Class[?] = classOf[ImplicitSearchFailure]
-    override def unapply(x: Any): Option[ImplicitSearchFailure] = x match
+  type GivenSearchFailure = Tree
+  def isInstanceOfGivenSearchFailure(given ctx: Context): IsInstanceOf[GivenSearchFailure] = new {
+    def runtimeClass: Class[?] = classOf[GivenSearchFailure]
+    override def unapply(x: Any): Option[GivenSearchFailure] = x match
       case x: Tree =>
         x.tpe match
           case _: SearchFailureType => Some(x)
           case _ => None
       case _ => None
   }
-  def ImplicitSearchFailure_explanation(self: ImplicitSearchFailure)(given Context): String =
+  def GivenSearchFailure_explanation(self: GivenSearchFailure)(given Context): String =
     self.tpe.asInstanceOf[SearchFailureType].explanation
 
-  type DivergingImplicit = Tree
-  def isInstanceOfDivergingImplicit(given ctx: Context): IsInstanceOf[DivergingImplicit] = new {
-    def runtimeClass: Class[?] = classOf[DivergingImplicit]
-    override def unapply(x: Any): Option[DivergingImplicit] = x match
+  type DivergingGiven = Tree
+  def isInstanceOfDivergingGiven(given ctx: Context): IsInstanceOf[DivergingGiven] = new {
+    def runtimeClass: Class[?] = classOf[DivergingGiven]
+    override def unapply(x: Any): Option[DivergingGiven] = x match
       case x: Tree =>
         x.tpe match
           case _: Implicits.DivergingImplicit => Some(x)
           case _ => None
       case _ => None
   }
 
-  type NoMatchingImplicits = Tree
-  def isInstanceOfNoMatchingImplicits(given ctx: Context): IsInstanceOf[NoMatchingImplicits] = new {
-    def runtimeClass: Class[?] = classOf[NoMatchingImplicits]
-    override def unapply(x: Any): Option[NoMatchingImplicits] = x match
+  type NoMatchingGiven = Tree
+  def isInstanceOfNoMatchingGiven(given ctx: Context): IsInstanceOf[NoMatchingGiven] = new {
+    def runtimeClass: Class[?] = classOf[NoMatchingGiven]
+    override def unapply(x: Any): Option[NoMatchingGiven] = x match
       case x: Tree =>
         x.tpe match
           case _: Implicits.NoMatchingImplicits => Some(x)
           case _ => None
       case _ => None
   }
 
-  type AmbiguousImplicits = Tree
-  def isInstanceOfAmbiguousImplicits(given ctx: Context): IsInstanceOf[AmbiguousImplicits] = new {
-    def runtimeClass: Class[?] = classOf[AmbiguousImplicits]
-    override def unapply(x: Any): Option[AmbiguousImplicits] = x match
+  type AmbiguousGiven = Tree
+  def isInstanceOfAmbiguousGiven(given ctx: Context): IsInstanceOf[AmbiguousGiven] = new {
+    def runtimeClass: Class[?] = classOf[AmbiguousGiven]
+    override def unapply(x: Any): Option[AmbiguousGiven] = x match
       case x: Tree =>
         x.tpe match
           case _: Implicits.AmbiguousImplicits => Some(x)

docs/docs/reference/metaprogramming/macros.md

@@ -569,13 +569,13 @@ sum
 ### Find implicits within a macro
 
 Similarly to the `summonFrom` construct, it is possible to make implicit search available
-in a quote context. For this we simply provide `scala.quoted.matching.searchImplicitExpr:
+in a quote context. For this we simply provide `scala.quoted.matching.summonExpr:
 
 ```scala
 inline def setFor[T]: Set[T] = ${ setForExpr[T] }
 
 def setForExpr[T: Type](given QuoteContext): Expr[Set[T]] = {
-  searchImplicitExpr[Ordering[T]] match {
+  summonExpr[Ordering[T]] match {
     case Some(ord) => '{ new TreeSet[T]()($ord) }
     case _ => '{ new HashSet[T] }
   }

library/src/scala/quoted/matching/package.scala

@@ -10,11 +10,11 @@ package object matching {
    *  @param tpe quoted type of the implicit parameter
    *  @param qctx current context
    */
-  def searchImplicitExpr[T](given tpe: Type[T], qctx: QuoteContext): Option[Expr[T]] = {
+  def summonExpr[T](given tpe: Type[T], qctx: QuoteContext): Option[Expr[T]] = {
     import qctx.tasty.{_, given}
-    searchImplicit(tpe.unseal.tpe) match {
-      case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
-      case isf: ImplicitSearchFailure => None
+    searchGiven(tpe.unseal.tpe) match {
+      case iss: GivenSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
+      case isf: GivenSearchFailure => None
     }
   }
 

library/src/scala/tasty/Reflection.scala

@@ -10,7 +10,7 @@ class Reflection(private[scala] val internal: CompilerInterface)
     with CommentOps
     with FlagsOps
     with IdOps
-    with ImplicitsOps
+    with GivenOps
     with ImportSelectorOps
     with QuotedOps
     with PositionOps
@@ -25,6 +25,6 @@ class Reflection(private[scala] val internal: CompilerInterface)
     with TypeOrBoundsOps { self =>
 
   def typeOf[T: scala.quoted.Type]: Type =
-    implicitly[scala.quoted.Type[T]].unseal.tpe
+    summon[scala.quoted.Type[T]].unseal.tpe
 
 }

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

@@ -1416,32 +1416,32 @@ trait CompilerInterface {
   // IMPLICITS
   //
 
-  type ImplicitSearchResult <: AnyRef
+  type GivenSearchResult <: AnyRef
 
-  type ImplicitSearchSuccess <: ImplicitSearchResult
-  def isInstanceOfImplicitSearchSuccess(given ctx: Context): IsInstanceOf[ImplicitSearchSuccess]
-  def ImplicitSearchSuccess_tree(self: ImplicitSearchSuccess)(given ctx: Context): Term
+  type GivenSearchSuccess <: GivenSearchResult
+  def isInstanceOfGivenSearchSuccess(given ctx: Context): IsInstanceOf[GivenSearchSuccess]
+  def GivenSearchSuccess_tree(self: GivenSearchSuccess)(given ctx: Context): Term
 
-  type ImplicitSearchFailure <: ImplicitSearchResult
-  def isInstanceOfImplicitSearchFailure(given ctx: Context): IsInstanceOf[ImplicitSearchFailure]
-  def ImplicitSearchFailure_explanation(self: ImplicitSearchFailure)(given ctx: Context): String
+  type GivenSearchFailure <: GivenSearchResult
+  def isInstanceOfGivenSearchFailure(given ctx: Context): IsInstanceOf[GivenSearchFailure]
+  def GivenSearchFailure_explanation(self: GivenSearchFailure)(given ctx: Context): String
 
-  type DivergingImplicit <: ImplicitSearchFailure
-  def isInstanceOfDivergingImplicit(given ctx: Context): IsInstanceOf[DivergingImplicit]
+  type DivergingGiven <: GivenSearchFailure
+  def isInstanceOfDivergingGiven(given ctx: Context): IsInstanceOf[DivergingGiven]
 
-  type NoMatchingImplicits <: ImplicitSearchFailure
-  def isInstanceOfNoMatchingImplicits(given ctx: Context): IsInstanceOf[NoMatchingImplicits]
+  type NoMatchingGiven <: GivenSearchFailure
+  def isInstanceOfNoMatchingGiven(given ctx: Context): IsInstanceOf[NoMatchingGiven]
 
-  type AmbiguousImplicits <: ImplicitSearchFailure
-  def isInstanceOfAmbiguousImplicits(given ctx: Context): IsInstanceOf[AmbiguousImplicits]
+  type AmbiguousGiven <: GivenSearchFailure
+  def isInstanceOfAmbiguousGiven(given ctx: Context): IsInstanceOf[AmbiguousGiven]
 
   /** Find an implicit of type `T` in the current scope given by `ctx`.
-   *  Return an `ImplicitSearchResult`.
+   *  Return an `GivenSearchResult`.
    *
    *  @param tpe type of the implicit parameter
    *  @param ctx current context
    */
-  def searchImplicit(tpe: Type)(given ctx: Context): ImplicitSearchResult
+  def searchGiven(tpe: Type)(given ctx: Context): GivenSearchResult
 
   /** Inline fn if it is an explicit closure possibly nested inside the expression of a block.
    *  Otherwise apply the arguments to the closure.

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

@@ -399,16 +399,16 @@ trait Core {
   /** FlagSet of a Symbol */
   type Flags = internal.Flags
 
-  type ImplicitSearchResult = internal.ImplicitSearchResult
+  type GivenSearchResult = internal.GivenSearchResult
 
-  type ImplicitSearchSuccess = internal.ImplicitSearchSuccess
+  type GivenSearchSuccess = internal.GivenSearchSuccess
 
-  type ImplicitSearchFailure = internal.ImplicitSearchFailure
+  type GivenSearchFailure = internal.GivenSearchFailure
 
-  type DivergingImplicit = internal.DivergingImplicit
+  type DivergingGiven = internal.DivergingGiven
 
-  type NoMatchingImplicits = internal.NoMatchingImplicits
+  type NoMatchingGiven = internal.NoMatchingGiven
 
-  type AmbiguousImplicits = internal.AmbiguousImplicits
+  type AmbiguousGiven = internal.AmbiguousGiven
 
 }

library/src/scala/tasty/reflect/GivenOps.scala

@@ -0,0 +1,46 @@
+package scala.tasty.reflect
+
+trait GivenOps extends Core {
+
+  def searchGiven(tpe: Type)(given ctx: Context): GivenSearchResult =
+    internal.searchGiven(tpe)
+
+  given (given Context): IsInstanceOf[GivenSearchSuccess] = internal.isInstanceOfGivenSearchSuccess
+
+  object IsGivenSearchSuccess
+    @deprecated("Use _: GivenSearchSuccess", "")
+    def unapply(isr: GivenSearchSuccess)(given ctx: Context): Option[GivenSearchSuccess] = Some(isr)
+
+  given successOps: extension (self: GivenSearchSuccess) {
+    def tree(given ctx: Context): Term = internal.GivenSearchSuccess_tree(self)
+  }
+
+  given (given Context): IsInstanceOf[GivenSearchFailure] = internal.isInstanceOfGivenSearchFailure
+
+  object IsGivenSearchFailure
+    @deprecated("Use _: GivenSearchFailure", "")
+    def unapply(isr: GivenSearchFailure)(given ctx: Context): Option[GivenSearchFailure] = Some(isr)
+
+  given failureOps: extension (self: GivenSearchFailure) {
+    def explanation(given ctx: Context): String = internal.GivenSearchFailure_explanation(self)
+  }
+
+  given (given Context): IsInstanceOf[DivergingGiven] = internal.isInstanceOfDivergingGiven
+
+  object IsDivergingGiven
+    @deprecated("Use _: DivergingGiven", "")
+    def unapply(isr: DivergingGiven)(given ctx: Context): Option[DivergingGiven] = Some(isr)
+
+  given (given Context): IsInstanceOf[NoMatchingGiven] = internal.isInstanceOfNoMatchingGiven
+
+  object IsNoMatchingGiven
+    @deprecated("Use _: NoMatchingGiven", "")
+    def unapply(isr: NoMatchingGiven)(given ctx: Context): Option[NoMatchingGiven] = Some(isr)
+
+  given (given Context): IsInstanceOf[AmbiguousGiven] = internal.isInstanceOfAmbiguousGiven
+
+  object IsAmbiguousGiven
+    @deprecated("Use _: AmbiguousGiven", "")
+    def unapply(isr: AmbiguousGiven)(given ctx: Context): Option[AmbiguousGiven] = Some(isr)
+
+}

library/src/scala/tasty/reflect/ImplicitsOps.scala

@@ -2,6 +2,6 @@
 -- Error: tests/neg-macros/delegate-match-1/Test_2.scala:6:2 -----------------------------------------------------------
 6 |  f // error
   |  ^
-  |  AmbiguousImplicits
+  |  AmbiguousGiven
   |  both value a1 in class Test1 and value a2 in class Test1 match type A
   | This location contains code that was inlined from Test_2.scala:6

tests/neg-macros/delegate-match-1.check

@@ -5,17 +5,17 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(given qctx: QuoteContext): Expr[Unit] = {
   import qctx.tasty.{_, given}
-  searchImplicit(('[A]).unseal.tpe) match {
-    case x: ImplicitSearchSuccess =>
+  searchGiven(('[A]).unseal.tpe) match {
+    case x: GivenSearchSuccess =>
       '{}
-    case x: DivergingImplicit => '{}
-      error("DivergingImplicit\n" + x.explanation, rootPosition)
+    case x: DivergingGiven => '{}
+      error("DivergingGiven\n" + x.explanation, rootPosition)
       '{}
-    case x: NoMatchingImplicits =>
-      error("NoMatchingImplicits\n" + x.explanation, rootPosition)
+    case x: NoMatchingGiven =>
+      error("NoMatchingGiven\n" + x.explanation, rootPosition)
       '{}
-    case x: AmbiguousImplicits =>
-      error("AmbiguousImplicits\n" + x.explanation, rootPosition)
+    case x: AmbiguousGiven =>
+      error("AmbiguousGiven\n" + x.explanation, rootPosition)
       '{}
   }
 }

tests/neg-macros/delegate-match-1/Macro_1.scala

@@ -2,6 +2,6 @@
 -- Error: tests/neg-macros/delegate-match-2/Test_2.scala:5:2 -----------------------------------------------------------
 5 |  f // error
   |  ^
-  |  DivergingImplicit
+  |  DivergingGiven
   |  method a1 in class Test produces a diverging implicit search when trying to match type A
   | This location contains code that was inlined from Test_2.scala:5

tests/neg-macros/delegate-match-2.check

@@ -5,17 +5,17 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(given qctx: QuoteContext): Expr[Unit] = {
   import qctx.tasty.{_, given}
-  searchImplicit(('[A]).unseal.tpe) match {
-    case x: ImplicitSearchSuccess =>
+  searchGiven(('[A]).unseal.tpe) match {
+    case x: GivenSearchSuccess =>
       '{}
-    case x: DivergingImplicit => '{}
-      error("DivergingImplicit\n" + x.explanation, rootPosition)
+    case x: DivergingGiven => '{}
+      error("DivergingGiven\n" + x.explanation, rootPosition)
       '{}
-    case x: NoMatchingImplicits =>
-      error("NoMatchingImplicits\n" + x.explanation, rootPosition)
+    case x: NoMatchingGiven =>
+      error("NoMatchingGiven\n" + x.explanation, rootPosition)
       '{}
-    case x: AmbiguousImplicits =>
-      error("AmbiguousImplicits\n" + x.explanation, rootPosition)
+    case x: AmbiguousGiven =>
+      error("AmbiguousGiven\n" + x.explanation, rootPosition)
       '{}
   }
 }

tests/neg-macros/delegate-match-2/Macro_1.scala

@@ -2,6 +2,6 @@
 -- Error: tests/neg-macros/delegate-match-3/Test_2.scala:3:2 -----------------------------------------------------------
 3 |  f // error
   |  ^
-  |  NoMatchingImplicits
+  |  NoMatchingGiven
   |  no implicit values were found that match type A
   | This location contains code that was inlined from Test_2.scala:3