Normalize contextualization of quotes an liftables

 * Redefine quote as ```def `'`[T](e: T): given QuoteContext => Expr[T]```
 * Redefine `Liftable.toExpr` as `def toExpr(x: T): given QuoteContext => Expr[T]`

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -838,9 +838,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
      *  The result can be the contents of a term or type quote, which
      *  will return a term or type tree respectively.
      */
-    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[(tpd.Tree, tpd.Tree)] = tree match {
-      case Apply(Apply(_, quoted :: Nil), qctx :: Nil) if tree.symbol.isQuote => Some((quoted, qctx))
-      case TypeApply(_, quoted :: Nil) if tree.symbol.isQuote => Some((quoted, Literal(Constants.Constant(null))))
+    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
+      case tree: GenericApply[Type] if tree.symbol.isQuote => Some(tree.args.head)
       case _ => None
     }
   }
@@ -857,30 +856,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case _ => None
     }
   }
-
-  /** Extractors for splices */
-  object SplicedExpr {
-    /** Extracts the content of a spliced tree.
-      *  The result can be the contents of a term or type splice, which
-      *  will return a term or type tree respectively.
-      */
-    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
-      case tree: tpd.Apply if tree.symbol.isSplice => Some(tree.args.head)
-      case _ => None
-    }
-  }
-
-  /** Extractors for splices */
-  object SplicedType {
-    /** Extracts the content of a spliced tree.
-      *  The result can be the contents of a term or type splice, which
-      *  will return a term or type tree respectively.
-      */
-    def unapply(tree: tpd.Tree)(implicit ctx: Context): Option[tpd.Tree] = tree match {
-      case tree: tpd.Select if tree.symbol.isSplice => Some(tree.qualifier)
-      case _ => None
-    }
-  }
 }
 
 object TreeInfo {

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -365,10 +365,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           changePrec (GlobalPrec) {
             keywordStr("throw ") ~ toText(args.head)
           }
-        else if (!printDebug && fun.hasType && fun.symbol == defn.InternalQuoted_exprQuote) {
-          val Apply(_, args2) = fun
-          keywordStr("'{") ~ toTextGlobal(args2, ", ") ~ keywordStr("}")
-        } else if (!printDebug && fun.hasType && fun.symbol == defn.InternalQuoted_exprSplice)
+        else if (!printDebug && fun.hasType && fun.symbol == defn.InternalQuoted_exprQuote)
+          keywordStr("'{") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
+        else if (!printDebug && fun.hasType && fun.symbol == defn.InternalQuoted_exprSplice)
           keywordStr("${") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
         else if (app.isGivenApply && !homogenizedView)
           changePrec(InfixPrec) {

compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

@@ -43,10 +43,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
   }
 
   /** Transform quoted trees while maintaining phase correctness */
-  override protected def transformQuotation(body: Tree, qctx: Tree, quote: Tree)(implicit ctx: Context): Tree = {
+  override protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree = {
     val body1 = transform(body)(quoteContext)
-    val qctx1 = transform(qctx)
-    super.transformQuotation(body1, qctx1, quote)
+    super.transformQuotation(body1, quote)
   }
 
   /** Transform splice
@@ -76,7 +75,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
   protected def checkLevel(tree: Tree)(implicit ctx: Context): Tree = {
     def checkTp(tp: Type): Type = checkType(tree.sourcePos).apply(tp)
     tree match {
-      case Quoted(_, _) | Spliced(_)  =>
+      case Quoted(_) | Spliced(_)  =>
         tree
       case tree: RefTree if tree.symbol.isAllOf(InlineParam) =>
         tree

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -175,39 +175,39 @@ class ReifyQuotes extends MacroTransform {
      *  `scala.quoted.Unpickler.unpickleExpr` that matches `tpe` with
      *  core and splices as arguments.
      */
-    override protected def transformQuotation(body: Tree, qctx: Tree, quote: Tree)(implicit ctx: Context): Tree = {
+    override protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree = {
       val isType = quote.symbol eq defn.InternalQuoted_typeQuote
       if (level > 0) {
         val body1 = nested(isQuote = true).transform(body)(quoteContext)
-        super.transformQuotation(body1, qctx, quote)
+        super.transformQuotation(body1, quote)
       }
       else body match {
         case body: RefTree if isCaptured(body.symbol, level + 1) =>
           // Optimization: avoid the full conversion when capturing `x`
           // in '{ x } to '{ ${x$1} } and go directly to `x$1`
-          capturers(body.symbol)(body).select(nme.apply).appliedTo(qctx)
+          capturers(body.symbol)(body)
         case _=>
           val (body1, splices) = nested(isQuote = true).splitQuote(body)(quoteContext)
           if (level == 0) {
             val body2 =
               if (body1.isType) body1
               else Inlined(Inliner.inlineCallTrace(ctx.owner, quote.sourcePos), Nil, body1)
-            pickledQuote(body2, splices, qctx, body.tpe, isType).withSpan(quote.span)
+            pickledQuote(body2, splices, body.tpe, isType).withSpan(quote.span)
           }
           else {
             body
           }
       }
     }
 
-    private def pickledQuote(body: Tree, splices: List[Tree], qctx: Tree, originalTp: Type, isType: Boolean)(implicit ctx: Context) = {
+    private def pickledQuote(body: Tree, splices: List[Tree], originalTp: Type, isType: Boolean)(implicit ctx: Context) = {
       def liftedValue[T](value: T, name: TermName) =
-        ref(defn.LiftableModule).select(name).select("toExpr".toTermName).appliedTo(Literal(Constant(value))).appliedTo(qctx)
+        ref(defn.LiftableModule).select(name).select("toExpr".toTermName).appliedTo(Literal(Constant(value)))
 
       def pickleAsValue[T](value: T) = {
         value match {
-          case null => ref(defn.QuotedExprModule).select("nullExpr".toTermName).appliedTo(qctx)
-          case _: Unit => ref(defn.QuotedExprModule).select("unitExpr".toTermName).appliedTo(qctx)
+          case null => ref(defn.QuotedExprModule).select("nullExpr".toTermName)
+          case _: Unit => ref(defn.QuotedExprModule).select("unitExpr".toTermName)
           case _: Boolean => liftedValue(value, "Liftable_Boolean_delegate".toTermName)
           case _: Byte => liftedValue(value, "Liftable_Byte_delegate".toTermName)
           case _: Short => liftedValue(value, "Liftable_Short_delegate".toTermName)
@@ -229,9 +229,7 @@ class ReifyQuotes extends MacroTransform {
           else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)) | defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)
         val pickledQuoteStrings = liftList(PickledQuotes.pickleQuote(body).map(x => Literal(Constant(x))), defn.StringType)
         val splicesList = liftList(splices, defn.FunctionType(1).appliedTo(defn.SeqType.appliedTo(defn.AnyType), spliceResType))
-        val pickled = meth.appliedTo(pickledQuoteStrings, splicesList)
-        if (isType) pickled
-        else pickled.appliedTo(qctx)
+        meth.appliedTo(pickledQuoteStrings, splicesList)
       }
 
       if (splices.nonEmpty) pickleAsTasty()

compiler/src/dotty/tools/dotc/transform/Splicer.scala

@@ -36,7 +36,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, pos: SourcePosition, classLoader: ClassLoader)(implicit ctx: Context): Tree = tree match {
-    case Quoted(quotedTree, _) => quotedTree
+    case Quoted(quotedTree) => quotedTree
     case _ =>
       val interpreter = new Interpreter(pos, classLoader)
       try {
@@ -66,7 +66,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case Quoted(_, _) => // ok
+    case Quoted(_) => // ok
     case _ =>
       type Env = Set[Symbol]
 
@@ -85,7 +85,7 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Apply(TypeApply(fn, _), quoted :: Nil), qctx :: Nil) if fn.symbol == defn.InternalQuoted_exprQuote =>
+        case Apply(Select(Apply(fn, quoted :: Nil), nme.apply), _) if fn.symbol == defn.InternalQuoted_exprQuote =>
           // OK
 
         case TypeApply(fn, quoted :: Nil) if fn.symbol == defn.InternalQuoted_typeQuote =>
@@ -171,9 +171,8 @@ object Splicer {
       }
     }
 
-    def interpretTree(tree: Tree)(implicit env: Env): Object = {
-      tree match {
-      case Apply(Apply(TypeApply(fn, _), quoted :: Nil), qctx :: _) if fn.symbol == defn.InternalQuoted_exprQuote =>
+    def interpretTree(tree: Tree)(implicit env: Env): Object = tree match {
+      case Apply(Select(Apply(TypeApply(fn, _), quoted :: Nil), nme.apply), _) if fn.symbol == defn.InternalQuoted_exprQuote =>
         val quoted1 = quoted match {
           case quoted: Ident if quoted.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
@@ -234,7 +233,7 @@ object Splicer {
 
       case _ =>
         unexpectedTree(tree)
-    }}
+    }
 
     private def interpretBlock(stats: List[Tree], expr: Tree)(implicit env: Env) = {
       var unexpected: Option[Object] = None

compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala

@@ -59,9 +59,9 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
   }
 
   /** Transform the quote `quote` which contains the quoted `body`. */
-  protected def transformQuotation(body: Tree, qctx: Tree, quote: Tree)(implicit ctx: Context): Tree = {
+  protected def transformQuotation(body: Tree, quote: Tree)(implicit ctx: Context): Tree = {
     quote match {
-      case Apply(t @ Apply(fun, _), _) => cpy.Apply(quote)(cpy.Apply(t)(fun, body :: Nil), qctx :: Nil)
+      case quote: Apply => cpy.Apply(quote)(quote.fun, body :: Nil)
       case quote: TypeApply => cpy.TypeApply(quote)(quote.fun, body :: Nil)
     }
   }
@@ -88,18 +88,15 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
 
       tree match {
 
-        case Quoted(quotedTree, qctx) =>
+        case Quoted(quotedTree) =>
           dropEmptyBlocks(quotedTree) match {
-            case SplicedExpr(t) =>
-              // TODO beta-reduce
-              transform(t).select(nme.apply).appliedTo(qctx) // '{ $x } --> x
-            case SplicedType(t) => transform(t) // '[ $x ] --> x
-            case _ => transformQuotation(quotedTree, qctx, tree)
+            case Spliced(t) => transform(t) // '{ $x } --> x
+            case _ => transformQuotation(quotedTree, tree)
           }
 
         case tree @ Spliced(splicedTree) =>
           dropEmptyBlocks(splicedTree) match {
-            case Quoted(t, _) => transform(t) // ${ 'x } --> x
+            case Quoted(t) => transform(t) // ${ 'x } --> x
             case _ => transformSplice(splicedTree, tree)
           }
 
@@ -113,9 +110,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
           // mark all bindings
           new TreeTraverser {
             def traverse(tree: Tree)(implicit ctx: Context): Unit = tree match {
-              case Quoted(t, qctx) =>
-                traverse(t)(quoteContext)
-                traverse(qctx)
+              case Quoted(t) => traverse(t)(quoteContext)
               case Splice(t) => traverse(t)(spliceContext)
               case _ =>
                 markDef(tree)

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -35,10 +35,6 @@ trait QuotesAndSplices { self: Typer =>
    *  while tracking the quotation level in the context.
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = track("typedQuote") {
-    val qctx = inferImplicitArg(defn.QuoteContextClass.typeRef, tree.span)
-    if (level == 0 && qctx.tpe.isInstanceOf[SearchFailureType])
-      ctx.error(missingArgMsg(qctx, defn.QuoteContextClass.typeRef, ""), ctx.source.atSpan(tree.span))
-
     tree.quoted match {
       case untpd.Splice(innerExpr) if tree.isTerm =>
         ctx.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.sourcePos)
@@ -49,7 +45,7 @@ trait QuotesAndSplices { self: Typer =>
     ctx.compilationUnit.needsStaging = true
     val tree1 =
       if (tree.quoted.isType) typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuote.termRef), tree.quoted :: Nil), pt)(quoteContext)
-      else if (ctx.mode.is(Mode.Pattern) && level == 0) typedQuotePattern(tree.quoted, pt, qctx)
+      else if (ctx.mode.is(Mode.Pattern) && level == 0) typedQuotePattern(tree, pt)
       else typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuote.termRef), tree.quoted), pt)(quoteContext)
     tree1.withSpan(tree.span)
   }
@@ -296,7 +292,12 @@ trait QuotesAndSplices { self: Typer =>
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(quoted: untpd.Tree, pt: Type, qctx: tpd.Tree)(implicit ctx: Context): Tree = {
+  private def typedQuotePattern(tree: untpd.Quote, pt: Type)(implicit ctx: Context): Tree = {
+    val qctx = inferImplicitArg(defn.QuoteContextClass.typeRef, tree.span)
+    if (level == 0 && qctx.tpe.isInstanceOf[SearchFailureType])
+      ctx.error(missingArgMsg(qctx, defn.QuoteContextClass.typeRef, ""), ctx.source.atSpan(tree.span))
+
+    val quoted = tree.quoted
     val exprPt = pt.baseType(defn.QuotedExprClass)
     val quotedPt = exprPt.argInfos.headOption match {
       case Some(argPt: ValueType) => argPt // excludes TypeBounds
@@ -347,7 +348,7 @@ trait QuotesAndSplices { self: Typer =>
     UnApply(
       fun = ref(defn.InternalQuotedMatcher_unapply.termRef).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
       implicits =
-        ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(shape.tpe).appliedTo(shape).appliedTo(qctx) ::
+          ref(defn.InternalQuoted_exprQuote.termRef).appliedToType(defn.AnyType).appliedTo(shape).select(nme.apply).appliedTo(qctx) ::
           Literal(Constant(typeBindings.nonEmpty)) ::
           qctx :: Nil,
       patterns = splicePat :: Nil,

library/src/scala/internal/Quoted.scala

@@ -7,7 +7,7 @@ object Quoted {
 
   /** A term quote is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.exprQuote`")
-  def exprQuote[T](x: T) given QuoteContext: Expr[T] = ???
+  def exprQuote[T](x: T): given QuoteContext => Expr[T] = ???
 
   /** A term splice is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.Quoted.exprSplice`")

library/src/scala/quoted/Expr.scala

@@ -48,13 +48,13 @@ package quoted {
     }
 
     /** Returns a null expresssion equivalent to `'{null}` */
-    def nullExpr given (qctx: QuoteContext): Expr[Null] = {
+    def nullExpr: given QuoteContext => Expr[Null] = given qctx => {
       import qctx.tasty._
       Literal(Constant(null)).seal.asInstanceOf[Expr[Null]]
     }
 
     /** Returns a unit expresssion equivalent to `'{}` or `'{()}` */
-    def unitExpr given (qctx: QuoteContext): Expr[Unit] = {
+    def unitExpr: given QuoteContext => Expr[Unit] = given qctx => {
       import qctx.tasty._
       Literal(Constant(())).seal.asInstanceOf[Expr[Unit]]
     }

library/src/scala/quoted/Liftable.scala

@@ -6,7 +6,7 @@ package scala.quoted
 trait Liftable[T] {
 
   /** Lift a value into an expression containing the construction of that value */
-  def toExpr(x: T) given QuoteContext: Expr[T]
+  def toExpr(x: T): given QuoteContext => Expr[T]
 
 }
 
@@ -29,15 +29,15 @@ object Liftable {
 
   private class PrimitiveLiftable[T <: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Liftable[T] {
     /** Lift a primitive value `n` into `'{ n }` */
-    def toExpr(x: T) given (qctx: QuoteContext): Expr[T] = {
+    def toExpr(x: T) = given qctx => {
       import qctx.tasty._
       Literal(Constant(x)).seal.asInstanceOf[Expr[T]]
     }
   }
 
   implicit def ClassIsLiftable[T]: Liftable[Class[T]] = new Liftable[Class[T]] {
     /** Lift a `Class[T]` into `'{ classOf[T] }` */
-    def toExpr(x: Class[T]) given (qctx: QuoteContext): Expr[Class[T]] = {
+    def toExpr(x: Class[T]) = given qctx => {
       import qctx.tasty._
       Ref(definitions.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
     }

library/src/scala/runtime/quoted/Unpickler.scala

@@ -14,7 +14,7 @@ object Unpickler {
   /** Unpickle `repr` which represents a pickled `Expr` tree,
    *  replacing splice nodes with `args`
    */
-  def unpickleExpr[T](repr: Pickled, args: Seq[Seq[Any] => ((given QuoteContext => Expr[Any]) | Type[_])]) given QuoteContext: Expr[T] = new TastyExpr[T](repr, args)
+  def unpickleExpr[T](repr: Pickled, args: Seq[Seq[Any] => ((given QuoteContext => Expr[Any]) | Type[_])]): given QuoteContext => Expr[T] = new TastyExpr[T](repr, args)
 
   /** Unpickle `repr` which represents a pickled `Type` tree,
    *  replacing splice nodes with `args`

library/src/scala/tasty/reflect/Printers.scala

@@ -806,7 +806,7 @@ trait Printers
           this += "throw "
           printTree(expr)
 
-        case Apply(Apply(fn, args), _) if fn.symbol.fullName == "scala.internal.Quoted$.exprQuote" =>
+        case Apply(fn, args) if fn.symbol.fullName == "scala.internal.Quoted$.exprQuote" =>
           args.head match {
             case Block(stats, expr) =>
               this += "'{"
@@ -834,6 +834,8 @@ trait Printers
         case Apply(fn, args) =>
           fn match {
             case Select(This(_), "<init>") => this += "this" // call to constructor inside a constructor
+            case Select(qual, "apply") if qual.tpe.classSymbol.exists(_.name.startsWith("ImplicitFunction")) =>
+              printTree(qual) += " given "
             case _ => printQualTree(fn)
           }
           val args1 = args match {

tests/pos/quote-liftable-list-2.scala

@@ -3,11 +3,7 @@ import scala.quoted._
 object Test {
 
   implicit def ListIsLiftableOr[T: Type, U: Type]: Liftable[List[T | U]] = new {
-    def toExpr(xs: List[T | U]) given QuoteContext: Expr[List[T | U]] = '{ Nil: List[T | U] }
-  }
-
-  implicit def ListIsLiftableAnd[T: Type, U: Type]: Liftable[List[T & U]] = new {
-    def toExpr(xs: List[T & U]) given QuoteContext: Expr[List[T & U]] = '{ Nil: List[T & U] }
+    def toExpr(xs: List[T | U]): given QuoteContext => Expr[List[T | U]] = '{ Nil: List[T | U] }
   }
 
 }

tests/pos/quote-liftable-list-3.scala

@@ -0,0 +1,9 @@
+import scala.quoted._
+
+object Test {
+
+  implicit def ListIsLiftableAnd[T: Type, U: Type]: Liftable[List[T & U]] = new {
+    def toExpr(xs: List[T & U]): given QuoteContext => Expr[List[T & U]] = '{ Nil: List[T & U] }
+  }
+
+}

tests/pos/quote-liftable-list.scala

@@ -3,7 +3,7 @@ import scala.quoted._
 object Test {
 
   implicit def ListIsLiftable[T: Liftable: Type]: Liftable[List[T]] = new {
-    def toExpr(xs: List[T]) given QuoteContext: Expr[List[T]] = '{ Nil: List[T] }
+    def toExpr(xs: List[T]) = '{ Nil: List[T] }
   }
 
 }