Fix #8045: Refine QuoteContext{val tasty} provided by splices

```
given qctx as QuoteContex = ???
'{
 ${ myExpr(summon[QuoteContext]) }
}
```

is now encoded as

```
given qctx as QuoteContex = ???
exprQuote {
  exprSplice {
  	(qctx0_$1: QuoteContext { val tasty: qctx.tasty.type }) ?=>
	  myExpr(summon[QuoteContext](qctx0_$1))
  }
}(given qctx)
```

Before `qctx0_$1` was typed as `QuoteContext`.

Intuitively, `qctx0_$1` is a sub-context of `qctx` where both share the same reflection interface

Author: nicolasstucki

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

@@ -1228,7 +1228,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val argType =
         if (baseType != NoType) baseType.argTypesHi.head
         else defn.NothingType
-      ref(defn.InternalQuoted_exprSplice).appliedToType(argType).appliedTo(tree)
+      ref(defn.InternalQuoted_exprSplice).appliedToTypes(List(argType, defn.QuoteContextClass.typeRef)).appliedTo(tree)
     }
     def unapply(tree: Tree)(implicit ctx: Context): Option[Tree] = tree match {
       case Apply(fn, arg :: Nil) if fn.symbol == defn.InternalQuoted_exprSplice => Some(arg)

compiler/src/dotty/tools/dotc/core/StagingContext.scala

@@ -1,6 +1,7 @@
 package dotty.tools.dotc.core
 
 import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.util.Property
 
 import scala.collection.mutable
@@ -10,6 +11,8 @@ object StagingContext {
   /** A key to be used in a context property that tracks the quoteation level */
   private val QuotationLevel = new Property.Key[Int]
 
+  private val QuotationContexts = new Property.Key[List[tpd.Tree]]
+
   /** All enclosing calls that are currently inlined, from innermost to outermost. */
   def level(implicit ctx: Context): Int =
     ctx.property(QuotationLevel).getOrElse(0)
@@ -18,8 +21,21 @@ object StagingContext {
   def quoteContext(implicit ctx: Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level + 1)
 
+  /** Context with an incremented quotation level. */
+  def pushQuoteContext(qctxRef: tpd.Tree)(implicit ctx: Context): Context =
+    val old = ctx.property(QuotationContexts).getOrElse(List.empty)
+    ctx.fresh.setProperty(QuotationLevel, level + 1)
+             .setProperty(QuotationContexts, qctxRef :: old)
+
   /** Context with a decremented quotation level. */
   def spliceContext(implicit ctx: Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level - 1)
+
+  def popQuoteContext()(implicit ctx: Context): (Option[tpd.Tree], Context) =
+    assert(level >= 0)
+    val head = ctx.property(QuotationContexts).flatMap(_.headOption)
+    val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
+                        .setProperty(QuotationContexts, ctx.property(QuotationContexts).map(_.drop(1)).getOrElse(Nil))
+    (head, ctx1)
 }
 

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

@@ -68,11 +68,11 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
   protected def transformSplice(body: Tree, splice: Tree)(implicit ctx: Context): Tree = {
     val body1 = transform(body)(spliceContext)
     splice match {
-      case Apply(fun: TypeApply, _) if splice.isTerm =>
+      case Apply(fun @ TypeApply(_, _ :: qctx :: Nil), _) if splice.isTerm =>
         // Type of the splice itsel must also be healed
         // internal.Quoted.expr[F[T]](... T ...)  -->  internal.Quoted.expr[F[$t]](... T ...)
         val tp = checkType(splice.sourcePos).apply(splice.tpe.widenTermRefExpr)
-        cpy.Apply(splice)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), body1 :: Nil)
+        cpy.Apply(splice)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: qctx :: Nil), body1 :: Nil)
       case splice: Select => cpy.Select(splice)(body1, splice.name)
     }
   }

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

@@ -232,7 +232,7 @@ class ReifyQuotes extends MacroTransform {
           else ref(defn.Unpickler_unpickleExpr).appliedToType(originalTp.widen)
         val spliceResType =
           if (isType) defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)
-          else defn.FunctionType(1, isContextual = true).appliedTo(defn.QuoteContextClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(defn.AnyType)) | defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)
+          else defn.AnyType // 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))
         meth.appliedTo(pickledQuoteStrings, splicesList)
@@ -394,7 +394,7 @@ class ReifyQuotes extends MacroTransform {
             val body = capturers(tree.symbol).apply(tree)
             val splice: Tree =
               if (tree.isType) body.select(tpnme.splice)
-              else ref(defn.InternalQuoted_exprSplice).appliedToType(tree.tpe).appliedTo(body)
+              else ref(defn.InternalQuoted_exprSplice).appliedToTypes(List(tree.tpe, defn.QuoteContextClass.typeRef)).appliedTo(body)
 
             transformSplice(body, splice)
 

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

@@ -90,7 +90,10 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
 
         case Quoted(quotedTree) =>
           dropEmptyBlocks(quotedTree) match {
-            case Spliced(t) => transform(t) // '{ $x } --> x
+            case Spliced(t) =>
+              // '{ $x } --> x
+              // and adapt the refinment of `QuoteContext { type tasty: ... } ?=> Expr[T]`
+              transform(t).asInstance(tree.tpe)
             case _ => transformQuotation(quotedTree, tree)
           }
 

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

@@ -54,7 +54,7 @@ trait QuotesAndSplices {
       else if (tree.quoted.isType)
         typedTypeApply(untpd.TypeApply(untpd.ref(defn.InternalQuoted_typeQuote.termRef), tree.quoted :: Nil), pt)(quoteContext)
       else
-        typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuote.termRef), tree.quoted), pt)(quoteContext).select(nme.apply).appliedTo(qctx)
+        typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuote.termRef), tree.quoted), pt)(pushQuoteContext(qctx)).select(nme.apply).appliedTo(qctx)
     tree1.withSpan(tree.span)
   }
 
@@ -91,19 +91,27 @@ trait QuotesAndSplices {
         markAsMacro(ctx)
       }
 
+      val (topQuoteContext, ctx1) =
+        if level < 0 then (None, spliceContext)
+        else  popQuoteContext()
+
       // Explicitly provide the given QuoteContext of the splice.
       //  * Avoids leaking implementation details of scala.internal.quoted.CompileTime.exprSplice,
       //    such as exprSplice taking a ?=> function argument
       //  * Provide meaningful names for QuoteContext synthesized by within `${ ... }`
-      //  * TODO preserve QuoteContext.tasty path dependent type (see comment below and #8045)
       val qctxParamName = NameKinds.UniqueName.fresh(s"qctx${level - 1}_".toTermName)
-      // TODO: Refine QuoteContext with the tasty context that the quote received
-      //       If encoloseing quote receives `qctx` then this type should be `QuoteContext { val tasty: qxtx.tasty.type }`
-      val qctxParamTpt = untpd.TypedSplice(TypeTree(defn.QuoteContextClass.typeRef))
+      val qctxParamTpe = topQuoteContext match {
+        case Some(qctxRef) =>
+          val reflectTpe = qctxRef.tpe.select(defn.QuoteContextClass.requiredValue("tasty"))
+          RefinedType(defn.QuoteContextClass.typeRef, "tasty".toTermName, reflectTpe)
+        case _ => defn.QuoteContextClass.typeRef
+      }
+      val qctxParamTpt = untpd.TypedSplice(TypeTree(qctxParamTpe))
+
       val qctxParam = untpd.makeParameter(qctxParamName, qctxParamTpt, untpd.Modifiers(Given))
       val expr = untpd.Function(List(qctxParam), tree.expr).withSpan(tree.span)
 
-      typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSplice.termRef), expr), pt)(spliceContext).withSpan(tree.span)
+      typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprSplice.termRef), expr), pt)(ctx1).withSpan(tree.span)
     }
   }
 

library/src-bootstrapped/scala/internal/quoted/CompileTime.scala

@@ -0,0 +1,48 @@
+package scala.internal.quoted
+
+import scala.annotation.{Annotation, compileTimeOnly}
+import scala.quoted._
+
+@compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime`")
+object CompileTime {
+
+  /** A term quote is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprQuote`")
+  def exprQuote[T](x: T): QuoteContext ?=> Expr[T] = ???
+
+  /** A term splice is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.exprSplice`")
+  def exprSplice[T, QCtx <: QuoteContext](x: QCtx ?=> Expr[T]): T = ???
+
+  /** A type quote is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.typeQuote`")
+  def typeQuote[T <: AnyKind]: Type[T] = ???
+
+  /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternHole`")
+  def patternHole[T]: T = ???
+
+  /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternBindHole`")
+  class patternBindHole extends Annotation
+
+  /** A splice of a name in a quoted pattern is that marks the definition of a type splice */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternType`")
+  class patternType extends Annotation
+
+  /** A type pattern that must be aproximated from above */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.fromAbove`")
+  class fromAbove extends Annotation
+
+  /** Artifact of pickled type splices
+   *
+   *  During quote reification a quote `'{ ... F[$t] ... }` will be transformed into
+   *  `'{ @quoteTypeTag type T$1 = $t ... F[T$1] ... }` to have a tree for `$t`.
+   *  This artifact is removed during quote unpickling.
+   *
+   *  See ReifyQuotes.scala and PickledQuotes.scala
+   */
+  @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.quoteTypeTag`")
+  class quoteTypeTag extends Annotation
+
+}

library/src/scala/internal/quoted/CompileTime.scala renamed to library/src-non-bootstrapped/scala/internal/quoted/CompileTime.scala

@@ -6,7 +6,7 @@ import scala.quoted.{Expr, QuoteContext, Type}
 object Unpickler {
 
   type PickledQuote = List[String]
-  type PickledExprArgs = Seq[Seq[Any] => ((QuoteContext ?=> Expr[Any]) | Type[_])]
+  type PickledExprArgs = Seq[Seq[Any] => Any]
   type PickledTypeArgs = Seq[Seq[Any] => Type[_]]
 
   /** Unpickle `repr` which represents a pickled `Expr` tree,

library/src/scala/internal/quoted/Unpickler.scala

@@ -0,0 +1,5 @@
+import scala.quoted._
+object Test
+  def run(using qctx: QuoteContext)(tree: qctx.tasty.Tree): Unit =
+    '{  ${ makeExpr(tree) } + 1  }
+  def makeExpr(using qctx: QuoteContext)(tree: qctx.tasty.Tree): Expr[Int] = ???

tests/pos/i8045.scala

@@ -1,4 +1,6 @@
 ((qctx: scala.quoted.QuoteContext) ?=> {
   val a: scala.quoted.Expr[scala.Int] = scala.internal.quoted.CompileTime.exprQuote[scala.Int](4).apply(using qctx)
-  ((qctx1_$1: scala.quoted.QuoteContext) ?=> a).apply(using qctx)
+  ((qctx1_$1: scala.quoted.QuoteContext {
+    val tasty: qctx.tasty
+  }) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.QuoteContext, scala.quoted.Expr[scala.Int]]].apply(using qctx)
 })

tests/run-staging/quote-nested-2.check

@@ -1,4 +1,6 @@
 ((qctx: scala.quoted.QuoteContext) ?=> {
   val a: scala.quoted.Expr[scala.Int] = scala.internal.quoted.CompileTime.exprQuote[scala.Int](4).apply(using qctx)
-  ((qctx2: scala.quoted.QuoteContext) ?=> ((qctx1_$1: scala.quoted.QuoteContext) ?=> a).apply(using qctx2)).apply(using qctx)
+  ((qctx2: scala.quoted.QuoteContext) ?=> ((qctx1_$1: scala.quoted.QuoteContext {
+    val tasty: qctx2.tasty
+  }) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.QuoteContext, scala.quoted.Expr[scala.Int]]].apply(using qctx2)).apply(using qctx)
 })