Refactor Reflect implicit search

Move implicit search method into implicit search module. This makes the Relfect API more design more homogeneous.

Author: nicolasstucki

community-build/community-projects/shapeless

@@ -2118,14 +2118,16 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
       end extension
     end IdMethodsImpl
 
-    type ImplicitSearchResult = Tree
+    type ImplicitSearch = Tree
 
-    def searchImplicit(tpe: Type): ImplicitSearchResult =
-      ctx.typer.inferImplicitArg(tpe, rootPosition.span)
+    object ImplicitSearch extends ImplicitSearchModule:
+      def apply(tpe: Type): ImplicitSearch =
+        ctx.typer.inferImplicitArg(tpe, rootPosition.span)
+    end ImplicitSearch
 
     type ImplicitSearchSuccess = Tree
 
-    object ImplicitSearchSuccessTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]:
+    object ImplicitSearchSuccessTypeTest extends TypeTest[ImplicitSearch, ImplicitSearchSuccess]:
       def runtimeClass: Class[?] = classOf[ImplicitSearchSuccess]
       override def unapply(x: Any): Option[ImplicitSearchSuccess] = x match
         case x: Tree @unchecked =>
@@ -2143,7 +2145,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
 
     type ImplicitSearchFailure = Tree
 
-    object ImplicitSearchFailureTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchFailure]:
+    object ImplicitSearchFailureTypeTest extends TypeTest[ImplicitSearch, ImplicitSearchFailure]:
       def runtimeClass: Class[?] = classOf[ImplicitSearchFailure]
       override def unapply(x: Any): Option[ImplicitSearchFailure] = x match
         case x: Tree @unchecked =>
@@ -2162,7 +2164,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
 
     type DivergingImplicit = Tree
 
-    object DivergingImplicitTypeTest extends TypeTest[ImplicitSearchResult, DivergingImplicit]:
+    object DivergingImplicitTypeTest extends TypeTest[ImplicitSearch, DivergingImplicit]:
       def runtimeClass: Class[?] = classOf[DivergingImplicit]
       override def unapply(x: Any): Option[DivergingImplicit] = x match
         case x: Tree @unchecked =>
@@ -2174,7 +2176,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
 
     type NoMatchingImplicits = Tree
 
-    object NoMatchingImplicitsTypeTest extends TypeTest[ImplicitSearchResult, NoMatchingImplicits]:
+    object NoMatchingImplicitsTypeTest extends TypeTest[ImplicitSearch, NoMatchingImplicits]:
       def runtimeClass: Class[?] = classOf[NoMatchingImplicits]
       override def unapply(x: Any): Option[NoMatchingImplicits] = x match
         case x: Tree @unchecked =>
@@ -2186,7 +2188,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
 
     type AmbiguousImplicits = Tree
 
-    object AmbiguousImplicitsTypeTest extends TypeTest[ImplicitSearchResult, AmbiguousImplicits]:
+    object AmbiguousImplicitsTypeTest extends TypeTest[ImplicitSearch, AmbiguousImplicits]:
       def runtimeClass: Class[?] = classOf[AmbiguousImplicits]
       override def unapply(x: Any): Option[AmbiguousImplicits] = x match
         case x: Tree @unchecked =>

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -180,7 +180,7 @@ object Expr {
     ofTupleFromSeq(elems).asExprOf[Tuple.InverseMap[T, Expr]]
   }
 
-  /** Find an implicit of type `T` in the current scope given by `qctx`.
+  /** Find a given instance of type `T` in the current scope.
    *  Return `Some` containing the expression of the implicit or
    * `None` if implicit resolution failed.
    *
@@ -190,7 +190,7 @@ object Expr {
    */
   def summon[T](using tpe: Type[T])(using qctx: QuoteContext): Option[Expr[T]] = {
     import qctx.tasty._
-    searchImplicit(tpe.unseal.tpe) match {
+    ImplicitSearch(tpe.unseal.tpe) match {
       case iss: ImplicitSearchSuccess => Some(iss.tree.seal.asInstanceOf[Expr[T]])
       case isf: ImplicitSearchFailure => None
     }

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -2409,21 +2409,25 @@ trait Reflection { reflection =>
   // IMPLICIT SEARCH //
   /////////////////////
 
-  // TODO: this should not be top level
-  /** Find an implicit of type `T` in the current scope given by `ctx`.
-   *  Return an `ImplicitSearchResult`.
-   *
-   *  @param tpe type of the implicit parameter
-   *  @param ctx current context
-   */
-  def searchImplicit(tpe: Type): ImplicitSearchResult
+  /** Result of a given instance search */
+  type ImplicitSearch <: AnyRef
+
+  given TypeTest[ImplicitSearch, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTest
+  protected val ImplicitSearchSuccessTypeTest: TypeTest[ImplicitSearch, ImplicitSearchSuccess]
 
-  type ImplicitSearchResult <: AnyRef
+  val ImplicitSearch: ImplicitSearchModule
 
-  given TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTest
-  protected val ImplicitSearchSuccessTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]
+  trait ImplicitSearchModule { self: ImplicitSearch.type =>
+    /** Find a given instance of type `T` in the current scope.
+     *  Return an `ImplicitSearch`.
+     *
+     *  @param tpe type of the implicit parameter
+     *  @param ctx current context
+     */
+    def apply(tpe: Type): ImplicitSearch
+  }
 
-  type ImplicitSearchSuccess <: ImplicitSearchResult
+  type ImplicitSearchSuccess <: ImplicitSearch
 
   given ImplicitSearchSuccessMethods as ImplicitSearchSuccessMethods = ImplicitSearchSuccessMethodsImpl
   protected val ImplicitSearchSuccessMethodsImpl: ImplicitSearchSuccessMethods
@@ -2434,10 +2438,10 @@ trait Reflection { reflection =>
     end extension
   end ImplicitSearchSuccessMethods
 
-  type ImplicitSearchFailure <: ImplicitSearchResult
+  type ImplicitSearchFailure <: ImplicitSearch
 
-  given TypeTest[ImplicitSearchResult, ImplicitSearchFailure] = ImplicitSearchFailureTypeTest
-  protected val ImplicitSearchFailureTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchFailure]
+  given TypeTest[ImplicitSearch, ImplicitSearchFailure] = ImplicitSearchFailureTypeTest
+  protected val ImplicitSearchFailureTypeTest: TypeTest[ImplicitSearch, ImplicitSearchFailure]
 
   given ImplicitSearchFailureMethods as ImplicitSearchFailureMethods = ImplicitSearchFailureMethodsImpl
   protected val ImplicitSearchFailureMethodsImpl: ImplicitSearchFailureMethods
@@ -2450,18 +2454,18 @@ trait Reflection { reflection =>
 
   type DivergingImplicit <: ImplicitSearchFailure
 
-  given TypeTest[ImplicitSearchResult, DivergingImplicit] = DivergingImplicitTypeTest
-  protected val DivergingImplicitTypeTest: TypeTest[ImplicitSearchResult, DivergingImplicit]
+  given TypeTest[ImplicitSearch, DivergingImplicit] = DivergingImplicitTypeTest
+  protected val DivergingImplicitTypeTest: TypeTest[ImplicitSearch, DivergingImplicit]
 
   type NoMatchingImplicits <: ImplicitSearchFailure
 
-  given TypeTest[ImplicitSearchResult, NoMatchingImplicits] = NoMatchingImplicitsTypeTest
-  protected val NoMatchingImplicitsTypeTest: TypeTest[ImplicitSearchResult, NoMatchingImplicits]
+  given TypeTest[ImplicitSearch, NoMatchingImplicits] = NoMatchingImplicitsTypeTest
+  protected val NoMatchingImplicitsTypeTest: TypeTest[ImplicitSearch, NoMatchingImplicits]
 
   type AmbiguousImplicits <: ImplicitSearchFailure
 
-  given TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTest
-  protected val AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearchResult, AmbiguousImplicits]
+  given TypeTest[ImplicitSearch, AmbiguousImplicits] = AmbiguousImplicitsTypeTest
+  protected val AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearch, AmbiguousImplicits]
 
   /////////////
   // SYMBOLS //

library/src/scala/tasty/Reflection.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext): Expr[Unit] = {
   import qctx.tasty._
-  searchImplicit(('[A]).unseal.tpe) match {
+  ImplicitSearch(('[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

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

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl (using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.tasty._
-  searchImplicit(('[A]).unseal.tpe) match {
+  ImplicitSearch(('[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

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

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.tasty._
-  searchImplicit(('[A]).unseal.tpe) match {
+  ImplicitSearch(('[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}