diff --git a/community-build/community-projects/sourcecode b/community-build/community-projects/sourcecode
index ba4edb34f9ac..e03cb3ee6e79 160000
--- a/community-build/community-projects/sourcecode
+++ b/community-build/community-projects/sourcecode
@@ -1 +1 @@
-Subproject commit ba4edb34f9ac4083d5eb4f025a3fbc98a1ebfc3d
+Subproject commit e03cb3ee6e79407ff836197d00ae91bf81367b49
diff --git a/compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala b/compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala
index 21756a781b6c..a60ad08769d3 100644
--- a/compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala
@@ -79,7 +79,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, QuoteUnpickl
     }
   end extension
 
-  object reflect extends scala.tasty.Reflection:
+  object reflect extends scala.quoted.Reflection:
 
     def rootContext: Context = ctx
 
diff --git a/library/src/scala/quoted/QuoteContext.scala b/library/src/scala/quoted/QuoteContext.scala
index b349b8ab54f3..ede10f80f1d0 100644
--- a/library/src/scala/quoted/QuoteContext.scala
+++ b/library/src/scala/quoted/QuoteContext.scala
@@ -66,7 +66,8 @@ trait QuoteContext { self: internal.QuoteUnpickler & internal.QuoteMatching =>
   /** Low-level Typed AST API metaprogramming API.
    *  This API does not have the static type guarantiees that `Expr` and `Type` provide.
    */
-  val reflect: scala.tasty.Reflection
+  val reflect: scala.quoted.Reflection
+  // TODO move Reflcetion definition in here
 
   /** Type of a QuoteContext provided by a splice within a quote that took this context.
    *  It is only required if working with the reflection API.
diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/quoted/Reflection.scala
similarity index 99%
rename from library/src/scala/tasty/Reflection.scala
rename to library/src/scala/quoted/Reflection.scala
index d18181f1bd38..c62c815a9cc7 100644
--- a/library/src/scala/tasty/Reflection.scala
+++ b/library/src/scala/quoted/Reflection.scala
@@ -1,8 +1,8 @@
-package scala.tasty
+package scala.quoted
 
 import scala.tasty.reflect._
 
-/** TASTy Reflect Interface.
+/** AST reflection interface.
  *
  *  Provides all functionality related with AST based metaprogramming.
  *
diff --git a/scala3doc/src/dotty/dokka/Main.scala b/scala3doc/src/dotty/dokka/Main.scala
index 98207a368288..648eca9463f9 100644
--- a/scala3doc/src/dotty/dokka/Main.scala
+++ b/scala3doc/src/dotty/dokka/Main.scala
@@ -9,7 +9,6 @@ import java.util.jar._
 import collection.JavaConverters._
 import collection.immutable.ArraySeq
 
-import scala.tasty.Reflection
 import scala.tasty.inspector.TastyInspector
 import java.nio.file.Files
 
diff --git a/scala3doc/src/dotty/dokka/tasty/BasicSupport.scala b/scala3doc/src/dotty/dokka/tasty/BasicSupport.scala
index 0d2dcac86833..0a872cdda522 100644
--- a/scala3doc/src/dotty/dokka/tasty/BasicSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/BasicSupport.scala
@@ -9,7 +9,7 @@ import dotty.dokka.model.api.Annotation
 trait BasicSupport:
   self: TastyParser =>
   import qctx.reflect._
-  object SymOps extends SymOps[qctx.reflect.type](qctx.reflect)
+  object SymOps extends SymOps[qctx.type](qctx)
   export SymOps._
 
   def parseAnnotation(annotTerm: Term): Annotation =
diff --git a/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala b/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala
index 87d0a8297248..1470f11d5a26 100644
--- a/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/ClassLikeSupport.scala
@@ -50,7 +50,7 @@ trait ClassLikeSupport:
           }
         )
 
-      val supertypes = getSupertypes(classDef).map {
+      val supertypes = getSupertypes(using qctx)(classDef).map {
         case (symbol, tpe) => LinkToType(tpe.dokkaType.asSignature, symbol.dri, kindForClasslike(symbol))
       }
       val selfSiangture: DSignature = typeForClass(classDef).dokkaType.asSignature
diff --git a/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala b/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
index 357e3404afce..34cad5ee5bd0 100644
--- a/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
@@ -32,9 +32,9 @@ trait ScaladocSupport { self: TastyParser =>
 
     val parser = commentSyntax match {
       case CommentSyntax.Wiki =>
-        comments.WikiCommentParser(comments.Repr(qctx.reflect)(tree.symbol))
+        comments.WikiCommentParser(comments.Repr(qctx)(tree.symbol))
       case CommentSyntax.Markdown =>
-        comments.MarkdownCommentParser(comments.Repr(qctx.reflect)(tree.symbol))
+        comments.MarkdownCommentParser(comments.Repr(qctx)(tree.symbol))
     }
     val parsed = parser.parse(preparsed)
 
diff --git a/scala3doc/src/dotty/dokka/tasty/SymOps.scala b/scala3doc/src/dotty/dokka/tasty/SymOps.scala
index bd7d589704c6..6ccafbbdf613 100644
--- a/scala3doc/src/dotty/dokka/tasty/SymOps.scala
+++ b/scala3doc/src/dotty/dokka/tasty/SymOps.scala
@@ -7,13 +7,14 @@ import dotty.dokka._
 import dotty.dokka.model.api.Visibility
 import dotty.dokka.model.api.VisibilityScope
 import dotty.dokka.model.api.Modifier
-import scala.tasty.Reflection
 
-class SymOps[R <: Reflection](val r: R):
-  import r._
+import scala.quoted._
 
-  given R = r
-  extension (sym: r.Symbol):
+class SymOps[Q <: QuoteContext](val q: Q):
+  import q.reflect._
+
+  given Q = q
+  extension (sym: Symbol):
     def packageName(using ctx: Context): String =
       if (sym.isPackageDef) sym.fullName
       else sym.maybeOwner.packageName
@@ -49,7 +50,7 @@ class SymOps[R <: Reflection](val r: R):
     // TODO: #49 Remove it after TASTY-Reflect release with published flag Extension
     def hackIsOpen: Boolean = {
       import dotty.tools.dotc
-      given dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+      given dotc.core.Contexts.Context = qctx.reflect.rootContext.asInstanceOf
       val symbol = sym.asInstanceOf[dotc.core.Symbols.Symbol]
       symbol.is(dotc.core.Flags.Open)
     }
diff --git a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
index d8d4078856f2..3acedfdb2584 100644
--- a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
@@ -1,6 +1,6 @@
 package dotty.dokka.tasty
 
-import scala.tasty.Reflection
+import scala.quoted._
 
 trait SyntheticsSupport:
   self: TastyParser =>
@@ -31,11 +31,11 @@ trait SyntheticsSupport:
 
     def isDefaultHelperMethod: Boolean = ".*\\$default\\$\\d+$".r.matches(s.name)
 
-    def isOpaque: Boolean = hackIsOpaque(qctx.reflect)(s)
+    def isOpaque: Boolean = hackIsOpaque(using qctx)(s)
 
-    def isInfix: Boolean = hackIsInfix(qctx.reflect)(s)
+    def isInfix: Boolean = hackIsInfix(using qctx)(s)
 
-    def getAllMembers: List[Symbol] = hackGetAllMembers(qctx.reflect)(s)
+    def getAllMembers: List[Symbol] = hackGetAllMembers(using qctx)(s)
 
   def isSyntheticField(c: Symbol) =
     c.flags.is(Flags.CaseAccessor) || c.flags.is(Flags.Object)
@@ -52,9 +52,10 @@ trait SyntheticsSupport:
     }
 
   // TODO: #49 Remove it after TASTY-Reflect release with published flag Extension
-  def hackIsInfix(r: Reflection)(rsym: r.Symbol): Boolean = {
+  def hackIsInfix(using QuoteContext)(rsym: qctx.reflect.Symbol): Boolean = {
+    import qctx.reflect._
     import dotty.tools.dotc
-    given ctx as dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given ctx as dotc.core.Contexts.Context = rootContext.asInstanceOf
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     ctx.definitions.isInfix(sym)
   }
@@ -62,43 +63,46 @@ trait SyntheticsSupport:
   They are valdefs that describe case companion objects and cases from enum.
   TASTY crashed when calling _.tree on them.
   */
-  def hackGetAllMembers(r: Reflection)(rsym: r.Symbol): List[r.Symbol] = {
+  def hackGetAllMembers(using QuoteContext)(rsym: qctx.reflect.Symbol): List[qctx.reflect.Symbol] = {
+    import qctx.reflect._
     import dotty.tools.dotc
-    given ctx as dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given ctx as dotc.core.Contexts.Context = rootContext.asInstanceOf
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef)).allMembers.iterator.map(_.symbol)
       .collect {
          case sym if
           !sym.is(dotc.core.Flags.ModuleVal) &&
           !sym.flags.isAllOf(dotc.core.Flags.Enum | dotc.core.Flags.Case | dotc.core.Flags.JavaStatic) =>
-              sym.asInstanceOf[r.Symbol]
+              sym.asInstanceOf[Symbol]
       }.toList
   }
 
-  def hackIsOpaque(r: Reflection)(rsym: r.Symbol): Boolean = {
+  def hackIsOpaque(using QuoteContext)(rsym: qctx.reflect.Symbol): Boolean = {
     import dotty.tools.dotc
-    given dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given dotc.core.Contexts.Context = qctx.reflect.rootContext.asInstanceOf
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     sym.is(dotc.core.Flags.Opaque)
   }
 
-  def hackGetSupertypes(r: Reflection)(rdef: r.ClassDef) = {
+  def hackGetSupertypes(using QuoteContext)(rdef: qctx.reflect.ClassDef) = {
+    import qctx.reflect._
     import dotty.tools.dotc
-    given dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given dotc.core.Contexts.Context = qctx.reflect.rootContext.asInstanceOf
     val classdef = rdef.asInstanceOf[dotc.ast.tpd.TypeDef]
     val ref = classdef.symbol.info.asInstanceOf[dotc.core.Types.ClassInfo].appliedRef
     val baseTypes: List[(dotc.core.Symbols.Symbol, dotc.core.Types.Type)] =
       ref.baseClasses.map(b => b -> ref.baseType(b))
-    baseTypes.asInstanceOf[List[(r.Symbol, r.TypeRepr)]]
+    baseTypes.asInstanceOf[List[(Symbol, TypeRepr)]]
   }
 
-  def getSupertypes(c: ClassDef) = hackGetSupertypes(qctx.reflect)(c).tail
+  def getSupertypes(using QuoteContext)(c: ClassDef) = hackGetSupertypes(c).tail
 
-  def typeForClass(c: ClassDef): r.TypeRepr =
+  def typeForClass(c: ClassDef): TypeRepr =
+    import qctx.reflect._
     import dotty.tools.dotc
-    given dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given dotc.core.Contexts.Context = rootContext.asInstanceOf
     val cSym = c.symbol.asInstanceOf[dotc.core.Symbols.Symbol]
-    cSym.typeRef.appliedTo(cSym.typeParams.map(_.typeRef)).asInstanceOf[r.TypeRepr]
+    cSym.typeRef.appliedTo(cSym.typeParams.map(_.typeRef)).asInstanceOf[TypeRepr]
 
   object MatchTypeCase:
     def unapply(tpe: TypeRepr): Option[(TypeRepr, TypeRepr)] =
diff --git a/scala3doc/src/dotty/dokka/tasty/comments/Comments.scala b/scala3doc/src/dotty/dokka/tasty/comments/Comments.scala
index cfccb9e8a982..0d52be0bb2df 100644
--- a/scala3doc/src/dotty/dokka/tasty/comments/Comments.scala
+++ b/scala3doc/src/dotty/dokka/tasty/comments/Comments.scala
@@ -8,8 +8,9 @@ import com.vladsch.flexmark.util.{ast => mdu}
 import com.vladsch.flexmark.formatter.Formatter
 import com.vladsch.flexmark.util.options.MutableDataSet
 
-import scala.tasty.Reflection
-class Repr(val r: Reflection)(val sym: r.Symbol)
+import scala.quoted._
+
+class Repr(val qctx: QuoteContext)(val sym: qctx.reflect.Symbol)
 
 case class Comment (
   body:                    dkkd.DocTag,
diff --git a/scala3doc/src/dotty/dokka/tasty/comments/MarkdownConverter.scala b/scala3doc/src/dotty/dokka/tasty/comments/MarkdownConverter.scala
index f2e22e6896ea..b97b621b2827 100644
--- a/scala3doc/src/dotty/dokka/tasty/comments/MarkdownConverter.scala
+++ b/scala3doc/src/dotty/dokka/tasty/comments/MarkdownConverter.scala
@@ -2,7 +2,6 @@ package dotty.dokka
 package tasty.comments
 
 import scala.jdk.CollectionConverters._
-import scala.tasty.Reflection
 
 import org.jetbrains.dokka.model.{doc => dkkd}
 import com.vladsch.flexmark.{ast => mda}
@@ -17,10 +16,10 @@ class MarkdownConverter(val repr: Repr) extends BaseConverter {
 
   // makeshift support for not passing an owner
   // see same in wiki.Converter
-  val r: repr.r.type = if repr == null then null else repr.r
-  val owner: r.Symbol = if repr == null then null.asInstanceOf[r.Symbol] else repr.sym
+  val qctx: repr.qctx.type = if repr == null then null else repr.qctx
+  val owner: qctx.reflect.Symbol = if repr == null then null.asInstanceOf[qctx.reflect.Symbol] else repr.sym
 
-  object SymOps extends SymOps[r.type](r)
+  object SymOps extends SymOps[qctx.type](qctx)
   import SymOps._
 
   def convertDocument(doc: mdu.Document): dkkd.DocTag = {
@@ -178,7 +177,7 @@ class MarkdownConverter(val repr: Repr) extends BaseConverter {
       List(dkk.text(resolved)).asJava
 
     withParsedQuery(queryStr) { query =>
-      MemberLookup.lookup(using r)(query, owner) match {
+      MemberLookup.lookup(using qctx)(query, owner) match {
         case Some((sym, targetText)) =>
           dkkd.DocumentationLink(sym.dri, resolveBody(default = targetText), kt.emptyMap)
         case None =>
diff --git a/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala b/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala
index 85b77eb378a7..f07a5350debd 100644
--- a/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala
+++ b/scala3doc/src/dotty/dokka/tasty/comments/MemberLookup.scala
@@ -1,27 +1,28 @@
 package dotty.dokka.tasty.comments
 
-import scala.tasty.Reflection
+import scala.quoted._
 
 trait MemberLookup {
 
-  def lookup(using r: Reflection)(
+  def lookup(using QuoteContext)(
     query: Query,
-    owner: r.Symbol,
-  ): Option[(r.Symbol, String)] = lookupOpt(query, Some(owner))
+    owner: qctx.reflect.Symbol,
+  ): Option[(qctx.reflect.Symbol, String)] = lookupOpt(query, Some(owner))
 
-  def lookupOpt(using r: Reflection)(
+  def lookupOpt(using QuoteContext)(
     query: Query,
-    ownerOpt: Option[r.Symbol],
-  ): Option[(r.Symbol, String)] = {
+    ownerOpt: Option[qctx.reflect.Symbol],
+  ): Option[(qctx.reflect.Symbol, String)] = {
+    import qctx.reflect._
 
-    def nearestClass(sym: r.Symbol): r.Symbol =
+    def nearestClass(sym: Symbol): Symbol =
       if sym.isClassDef then sym else nearestClass(sym.owner)
 
-    def nearestPackage(sym: r.Symbol): r.Symbol =
-      if sym.flags.is(r.Flags.Package) then sym else nearestPackage(sym.owner)
+    def nearestPackage(sym: Symbol): Symbol =
+      if sym.flags.is(Flags.Package) then sym else nearestPackage(sym.owner)
 
-    def nearestMembered(sym: r.Symbol): r.Symbol =
-      if sym.isClassDef || sym.flags.is(r.Flags.Package) then sym else nearestMembered(sym.owner)
+    def nearestMembered(sym: Symbol): Symbol =
+      if sym.isClassDef || sym.flags.is(Flags.Package) then sym else nearestMembered(sym.owner)
 
     val res =
       ownerOpt match {
@@ -41,11 +42,11 @@ trait MemberLookup {
               downwardLookup(rest.asList, nearestCls).map(_ -> rest.join)
             case Query.QualifiedId(Query.Qual.Id(id), _, rest) if id == nearestPkg.name =>
               downwardLookup(rest.asList, nearestPkg).map(_ -> rest.join)
-            case query: Query.QualifiedId => downwardLookup(query.asList, r.defn.RootPackage).map(_ -> query.join)
+            case query: Query.QualifiedId => downwardLookup(query.asList, defn.RootPackage).map(_ -> query.join)
           }
 
         case None =>
-          downwardLookup(query.asList, r.defn.RootPackage).map(_ -> query.join)
+          downwardLookup(query.asList, defn.RootPackage).map(_ -> query.join)
       }
 
     // println(s"looked up `$query` in ${owner.show}[${owner.flags.show}] as ${res.map(_.show)}")
@@ -53,22 +54,23 @@ trait MemberLookup {
     res
   }
 
-  private def hackMembersOf(using r: Reflection)(rsym: r.Symbol) = {
+  private def hackMembersOf(using QuoteContext)(rsym: qctx.reflect.Symbol) = {
+    import qctx.reflect._
     import dotty.tools.dotc
-    given dotc.core.Contexts.Context = r.rootContext.asInstanceOf
+    given dotc.core.Contexts.Context = rootContext.asInstanceOf
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     val members = sym.info.decls.iterator
     // println(s"members of ${sym.show} : ${members.map(_.show).mkString(", ")}")
-    members.asInstanceOf[Iterator[r.Symbol]]
+    members.asInstanceOf[Iterator[Symbol]]
   }
 
-  private def localLookup(using r: Reflection)(query: String, owner: r.Symbol): Option[r.Symbol] = {
-    import r._
+  private def localLookup(using QuoteContext)(query: String, owner: qctx.reflect.Symbol): Option[qctx.reflect.Symbol] = {
+    import qctx.reflect._
 
-    inline def whenExists(s: Symbol)(otherwise: => Option[r.Symbol]): Option[r.Symbol] =
+    inline def whenExists(s: Symbol)(otherwise: => Option[Symbol]): Option[Symbol] =
       if s.exists then Some(s) else otherwise
 
-    def findMatch(syms: Iterator[r.Symbol]): Option[r.Symbol] = {
+    def findMatch(syms: Iterator[Symbol]): Option[Symbol] = {
       // Scaladoc overloading support allows terminal * (and they're meaningless)
       val cleanQuery = query.stripSuffix("*")
       val (q, forceTerm, forceType) =
@@ -79,14 +81,14 @@ trait MemberLookup {
         else
           (cleanQuery, false, false)
 
-      def matches(s: r.Symbol): Boolean =
+      def matches(s: Symbol): Boolean =
         s.name == q && (
           if forceTerm then s.isTerm
           else if forceType then s.isType
           else true
         )
 
-      def hackResolveModule(s: r.Symbol): r.Symbol =
+      def hackResolveModule(s: Symbol): Symbol =
         if s.flags.is(Flags.Object) then s.moduleClass else s
 
       val matched = syms.find(matches)
@@ -108,14 +110,14 @@ trait MemberLookup {
       findMatch(hackMembersOf(owner))
     else
       owner.tree match {
-        case tree: r.ClassDef =>
-          findMatch(tree.body.iterator.collect { case t: r.Definition => t.symbol })
+        case tree: ClassDef =>
+          findMatch(tree.body.iterator.collect { case t: Definition => t.symbol })
         case _ =>
           findMatch(hackMembersOf(owner))
       }
   }
 
-  private def downwardLookup(using r: Reflection)(query: List[String], owner: r.Symbol): Option[r.Symbol] =
+  private def downwardLookup(using QuoteContext)(query: List[String], owner: qctx.reflect.Symbol): Option[qctx.reflect.Symbol] =
     query match {
       case Nil => None
       case q :: Nil => localLookup(q, owner)
diff --git a/scala3doc/src/dotty/dokka/tasty/comments/wiki/Converter.scala b/scala3doc/src/dotty/dokka/tasty/comments/wiki/Converter.scala
index 6575f9fbbbac..1e6b526773db 100644
--- a/scala3doc/src/dotty/dokka/tasty/comments/wiki/Converter.scala
+++ b/scala3doc/src/dotty/dokka/tasty/comments/wiki/Converter.scala
@@ -2,7 +2,6 @@ package dotty.dokka.tasty.comments
 package wiki
 
 import scala.jdk.CollectionConverters._
-import scala.tasty.Reflection
 
 import org.jetbrains.dokka.model.{doc => dkkd}
 
@@ -13,10 +12,10 @@ class Converter(val repr: Repr) extends BaseConverter {
 
   // makeshift support for not passing an owner
   // see same in MarkdownConverter
-  val r: repr.r.type = if repr == null then null else repr.r
-  val owner: r.Symbol = if repr == null then null.asInstanceOf[r.Symbol] else repr.sym
+  val qctx: repr.qctx.type = if repr == null then null else repr.qctx
+  val owner: qctx.reflect.Symbol = if repr == null then null.asInstanceOf[qctx.reflect.Symbol] else repr.sym
 
-  object SymOps extends SymOps[r.type](r)
+  object SymOps extends SymOps[qctx.type](qctx)
   import SymOps._
 
   def convertBody(body: Body): dkkd.DocTag = {
@@ -131,7 +130,7 @@ class Converter(val repr: Repr) extends BaseConverter {
       }
 
     withParsedQuery(queryStr) { query =>
-      MemberLookup.lookup(using r)(query, owner) match {
+      MemberLookup.lookup(using qctx)(query, owner) match {
         case Some((sym, targetText)) =>
           dkkd.DocumentationLink(sym.dri, resolveBody(default = targetText), kt.emptyMap)
         case None =>
diff --git a/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala b/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala
index ba77280f9616..d2c70329748a 100644
--- a/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala
+++ b/scala3doc/test/dotty/dokka/tasty/comments/MemberLookupTests.scala
@@ -1,12 +1,12 @@
 package dotty.dokka.tasty.comments
 
-import scala.tasty.Reflection
+import scala.quoted.QuoteContext
 
 import org.junit.{Test, Rule}
 import org.junit.Assert.{assertSame, assertTrue}
 import dotty.dokka.BuildInfo
 
-class LookupTestCases[R <: Reflection](val r: R) {
+class LookupTestCases[Q <: QuoteContext](val q: QuoteContext) {
 
   def testAll(): Unit = {
     testOwnerlessLookup()
@@ -74,17 +74,17 @@ class LookupTestCases[R <: Reflection](val r: R) {
     assertTrue("strict member lookup should not look outside", MemberLookup.lookup(parseQuery(query), owner).isEmpty)
   }
 
-  given r.type = r
+  given q.type = q
 
   def parseQuery(query: String): Query = {
     val Right(parsed) = QueryParser(query).tryReadQuery()
     parsed
   }
 
-  case class Sym(symbol: r.Symbol) {
+  case class Sym(symbol: q.reflect.Symbol) {
     def fld(name: String) =
-      def hackResolveModule(s: r.Symbol): r.Symbol =
-        if s.flags.is(r.Flags.Object) then s.moduleClass else s
+      def hackResolveModule(s: q.reflect.Symbol): q.reflect.Symbol =
+        if s.flags.is(q.reflect.Flags.Object) then s.moduleClass else s
       Sym(hackResolveModule(symbol.field(name)))
     def fun(name: String) =
       val List(sym) = symbol.method(name)
@@ -92,7 +92,7 @@ class LookupTestCases[R <: Reflection](val r: R) {
     def tpe(name: String) = Sym(symbol.typeMember(name))
   }
 
-  def cls(fqn: String) = Sym(r.Symbol.classSymbol(fqn))
+  def cls(fqn: String) = Sym(q.reflect.Symbol.classSymbol(fqn))
 }
 
 class MemberLookupTests {
@@ -105,13 +105,13 @@ class MemberLookupTests {
 
       override def processCompilationUnit(using ctx: quoted.QuoteContext)(root: ctx.reflect.Tree): Unit =
         if !alreadyRan then
-          this.test()(using ctx.reflect)
+          this.test()
           alreadyRan = true
 
-      def test()(using r: Reflection): Unit = {
+      def test()(using q: QuoteContext): Unit = {
         import dotty.dokka.tasty.comments.MemberLookup
 
-        val cases = LookupTestCases[r.type](r)
+        val cases = LookupTestCases[q.type](q)
 
         cases.testAll()
       }
diff --git a/tests/neg-macros/i6324.scala b/tests/neg-macros/i6324.scala
index cab1df5a3c0a..c38245665747 100644
--- a/tests/neg-macros/i6324.scala
+++ b/tests/neg-macros/i6324.scala
@@ -1,5 +1,5 @@
 class Test {
-  def res(x: quoted.Expr[Int])(using tasty.Reflection): quoted.Expr[Int] = x match {
+  def res(x: quoted.Expr[Int])(using quoted.Reflection): quoted.Expr[Int] = x match {
     case '{ 1 + $b } => // error: Type must be fully defined. Consider annotating the splice using a type ascription: (${b}: XYZ).
       b // error: Not found: b
   }
diff --git a/tests/neg-macros/i6325.scala b/tests/neg-macros/i6325.scala
index e925f890a454..e72a4ee11f23 100644
--- a/tests/neg-macros/i6325.scala
+++ b/tests/neg-macros/i6325.scala
@@ -1,5 +1,5 @@
 object Test {
-  def res(x: quoted.Expr[Int])(using tasty.Reflection): quoted.Expr[Int] = x match {
+  def res(x: quoted.Expr[Int])(using quoted.Reflection): quoted.Expr[Int] = x match {
     case '{ 1 + (${Bind(b)}: Int) } => ??? // error: Not found: Bind
     case _ => ???
   }
diff --git a/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala b/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala
index 382b79a18fbb..5c9e3d770007 100644
--- a/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala
+++ b/tests/pos-special/fatal-warnings/tasty-parent-unapply.scala
@@ -1,12 +1,10 @@
 import scala.quoted._
 
-import scala.tasty.Reflection
-
 object Macros {
 
 
-  def impl(reflect: Reflection): Unit = {
-    import reflect.{_, given}
+  def impl(using QuoteContext): Unit = {
+    import qctx.reflect._
 
     def foo(tree: Tree, term: Term, typeTree: TypeTree, parent: Tree) = {
 
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
index 05627fd93354..8eb690b35482 100644
--- a/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
+++ b/tests/run-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
@@ -2,7 +2,6 @@ package scala.tasty.interpreter
 
 import scala.quoted._
 import scala.tasty.interpreter.jvm.JVMReflection
-import scala.tasty.Reflection
 
 abstract class TreeInterpreter[QCtx <: QuoteContext & Singleton](using val qctx: QCtx) {
   import qctx.reflect._
@@ -196,7 +195,7 @@ abstract class TreeInterpreter[QCtx <: QuoteContext & Singleton](using val qctx:
   private def isNumericPrimitive(tpe: TypeRepr): Boolean =
     isIntegralPrimitive(tpe) || isFractionalPrimitive(tpe)
 
-  private def isIntegralPrimitive(tpe: TypeRepr): Boolean ={ 
+  private def isIntegralPrimitive(tpe: TypeRepr): Boolean = {
     tpe <:< TypeRepr.of[Byte] ||
     tpe <:< TypeRepr.of[Char] ||
     tpe <:< TypeRepr.of[Short] ||
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
index 4a04970464b9..532eedcc4dd5 100644
--- a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
+++ b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/Interpreter.scala
@@ -3,7 +3,6 @@ package jvm
 
 import scala.quoted._
 import scala.tasty.interpreter.jvm.JVMReflection
-import scala.tasty.Reflection
 
 class Interpreter[QCtx <: QuoteContext & Singleton](using qctx0: QCtx) extends TreeInterpreter[QCtx] {
   import qctx.reflect._
diff --git a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
index d6397ff52798..be66762a7756 100644
--- a/tests/run-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
+++ b/tests/run-custom-args/tasty-interpreter/interpreter/jvm/JVMReflection.scala
@@ -1,7 +1,6 @@
 package scala.tasty.interpreter.jvm
 
 import scala.quoted._
-import scala.tasty.Reflection
 
 class JVMReflection[QCtx <: QuoteContext & Singleton](using val tasty: QCtx) {
   import qctx.reflect._