Merge pull request #7728 from dotty-staging/add-macro-docs

Add docs on getting precise type within quotes

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -689,6 +689,50 @@ private def sumExpr(args1: Seq[Expr[Int]])(given QuoteContext): Expr[Int] = {
 }
 ```
 
+#### Recovering precise types using patterns
+
+Sometimes it is necessary to get a more precise type for an expression. This can be achived using the following pattern match.
+
+```scala
+def f(exp: Expr[Any]) =
+  expr match
+    case '{ $x: $t } =>
+      // If the pattern match succeeds, then there is some type `T` such that
+      // - `x` is bound to a variable of type `Expr[T]`
+      // - `t` is bound to a given instance of type `Type[T]`
+      // That is, we have `x: Expr[T]` and `given t: Type[T]`, for some (unknown) type `T`.
+```
+
+This might be used to then perform an implicit search as in:
+
+
+```scala
+inline def (sc: StringContext) showMe(args: =>Any*): String = ${ showMeExpr('sc, 'args) }
+
+private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(given qctx: QuoteContext): Expr[String] = {
+  argsExpr match {
+    case ExprSeq(argExprs) =>
+      val argShowedExprs = argExprs.map {
+        case '{ $arg: $tp } =>
+          val showTp = '[Show[$tp]]
+          summonExpr(given showTp)) match {
+            case Some(showExpr) => '{ $showExpr.show($arg) }
+            case None => qctx.error(s"could not find implicit for ${showTp.show}", arg); '{???}
+          }
+      }
+      val newArgsExpr = Expr.ofSeq(argShowedExprs)
+      '{ $sc.s($newArgsExpr: _*) }
+    case _ =>
+      // `new StringContext(...).showMeExpr(args: _*)` not an explicit `showMeExpr"..."`
+      qctx.error(s"Args must be explicit", argsExpr)
+      '{???}
+  }
+}
+
+trait Show[-T] {
+  def show(x: T): String
+}
+```
 
 ### More details
 [More details](./macros-spec.md)

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

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

tests/run-macros/string-context-implicits/Macro_1.scala

@@ -9,7 +9,7 @@ private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(given
       val argShowedExprs = argExprs.map {
         case '{ $arg: $tp } =>
           val showTp = '[Show[$tp]]
-          summonExpr(given showTp, summon[QuoteContext]) match {
+          summonExpr(given showTp) match {
             case Some(showExpr) => '{ $showExpr.show($arg) }
             case None => qctx.error(s"could not find implicit for ${showTp.show}", arg); '{???}
           }