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: qctx.NestedContext) ?=>
	  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,11 @@ object StagingContext {
   /** A key to be used in a context property that tracks the quoteation level */
   private val QuotationLevel = new Property.Key[Int]
 
+  /** A key to be used in a context property that tracks the quoteation stack.
+   *  Stack containing the QuoteContext references recieved by the surrounding quotes.
+   */
+  private val QuoteQontextStack = 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 +24,27 @@ object StagingContext {
   def quoteContext(implicit ctx: Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level + 1)
 
+  /** Context with an incremented quotation level and pushes a refecence to a QuoteContext on the quote context stack */
+  def pushQuoteContext(qctxRef: tpd.Tree)(implicit ctx: Context): Context =
+    val old = ctx.property(QuoteQontextStack).getOrElse(List.empty)
+    ctx.fresh.setProperty(QuotationLevel, level + 1)
+             .setProperty(QuoteQontextStack, qctxRef :: old)
+
   /** Context with a decremented quotation level. */
   def spliceContext(implicit ctx: Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level - 1)
-}
 
+  /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
+   *  The quotation stack could be empty if we are in a top level splice or an eroneous splice directly witin a top level splice.
+   */
+  def popQuoteContext()(implicit ctx: Context): (Option[tpd.Tree], Context) =
+    val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
+    val head =
+      ctx.property(QuoteQontextStack) match
+        case Some(x :: xs) =>
+          ctx1.setProperty(QuoteQontextStack, xs)
+          Some(x)
+        case _ =>
+          None // Splice at level 0 or lower
+    (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,23 @@ trait QuotesAndSplices {
         markAsMacro(ctx)
       }
 
+      val (outerQctx, ctx1) = 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))
+      //  * If within a quote, provide a QuoteContext is linked typewise with the outer QuoteContext
+      val qctxParamName = NameKinds.UniqueName.fresh(s"qctx${if level > 0 then level - 1 else ""}_".toTermName)
+      val qctxParamTpe = outerQctx match {
+        case Some(qctxRef) => qctxRef.tpe.select("NestedContext".toTypeName)
+        case _ => defn.QuoteContextClass.typeRef // splice at level 0 (or lower)
+      }
+      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
+
+}

…/scala/internal/quoted/CompileTime.scala …/scala/internal/quoted/CompileTime.scalalibrary/src/scala/internal/quoted/CompileTime.scala renamed to library/src-non-bootstrapped/scala/internal/quoted/CompileTime.scala 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

@@ -10,13 +10,32 @@ import scala.quoted.show.SyntaxHighlight
  *
  *  @param tasty Typed AST API. Usage: `def f(qctx: QuoteContext) = { import qctx.tasty.{_, given}; ... }`.
  */
-class QuoteContext(val tasty: scala.tasty.Reflection) {
+class QuoteContext(val tasty: scala.tasty.Reflection) { self =>
 
+  /** Type of a QuoteContext profided by a splice within a quote that took this context.
+   *  It is only required if working with the reflection API.
+   *
+   *  Usually it is infered by the quotes an splices typing. But sometimes it is necessary
+   *  to explicitly state that a context is nested as in the following example:
+   *
+   *  ```scala
+   *  def run(using qctx: QuoteContext)(tree: qctx.tasty.Tree): Unit =
+   *    def nested()(using qctx.NestedContext): Expr[Int] = '{  ${ makeExpr(tree) } + 1  }
+   *    '{  ${ nested() } + 2 }
+   *  def makeExpr(using qctx: QuoteContext)(tree: qctx.tasty.Tree): Expr[Int] = ???
+   *  ```
+   */
+  type NestedContext = QuoteContext {
+    val tasty: self.tasty.type
+  }
+
+  /** Show the fully elaborated source code representation of an expression */
   def show(expr: Expr[_], syntaxHighlight: SyntaxHighlight): String = {
     import tasty.{_, given}
     expr.unseal.showWith(syntaxHighlight)
   }
 
+  /** Show the fully elaborated source code representation of a type */
   def show(tpe: Type[_], syntaxHighlight: SyntaxHighlight): String = {
     import tasty.{_, given}
     tpe.unseal.showWith(syntaxHighlight)