Add abstractions for ByName arguments to Quotes

Author: odersky

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -930,6 +930,29 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end ReturnMethods
 
+    type ByNameArg = tpd.ByName
+
+    object ByNameArgTypeTest extends TypeTest[Tree, ByNameArg]:
+      def unapply(x: Tree): Option[ByNameArg & x.type] = x match
+        case tpt: (tpd.ByName & x.type) => Some(tpt)
+        case _ => None
+    end ByNameArgTypeTest
+
+    object ByNameArg extends ByNameArgModule:
+      def apply(result: TypeTree): ByNameArg =
+        withDefaultPos(tpd.ByName(result))
+      def copy(original: Tree)(result: TypeTree): ByNameArg =
+        tpd.cpy.ByName(original)(result)
+      def unapply(x: ByNameArg): Some[TypeTree] =
+        Some(x.expr)
+    end ByNameArg
+
+    given ByNameArgMethods: ByNameArgMethods with
+      extension (self: ByNameArg)
+        def expr: TypeTree = self.expr
+      end extension
+    end ByNameArgMethods
+
     type Repeated = tpd.SeqLiteral
 
     object RepeatedTypeTest extends TypeTest[Tree, Repeated]:

compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala

@@ -110,6 +110,8 @@ object Extractors {
         this += "SummonFrom(" ++= cases += ")"
       case Return(expr, from) =>
         this += "Return(" += expr += ", " += from += ")"
+      case ByNameArg(result) =>
+        this += "ByNameArg(" += result += ")"
       case While(cond, body) =>
         this += "While(" += cond += ", " += body += ")"
       case Try(block, handlers, finalizer) =>

library/src/scala/quoted/Quotes.scala

@@ -1498,6 +1498,32 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       end extension
     end ReturnMethods
 
+    /** A delayed <by-name> argument for a call-by=name parameter */
+    type ByNameArg <: Term
+
+    /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `ByNameArg` */
+    given ByNameArgTypeTest: TypeTest[Tree, ByNameArg]
+
+    /** Module object of `a <by-name>` argument */
+    val ByNameArg: ByNameArgModule
+
+    /** Methods of the module object `val ByNameArg` */
+    trait ByNameArgModule { this: ByNameArg.type =>
+      def apply(result: TypeTree): ByNameArg
+      def copy(original: Tree)(result: TypeTree): ByNameArg
+      def unapply(x: ByNameArg): Some[TypeTree]
+    }
+
+    /** Makes extension methods on `ByNameArg` available without any imports */
+    given ByNameArgMethods: ByNameArgMethods
+
+    /** Extension methods of `ByNameArg` */
+    trait ByNameArgMethods:
+      extension (self: ByNameArg)
+        def expr: TypeTree
+      end extension
+    end ByNameArgMethods
+
     /** Tree representing a variable argument list in the source code */
     type Repeated <: Term