Use q as default parameter name for Quotes

Also remove unnecessary names for `Quotes`

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -74,7 +74,7 @@ object PickledQuotes {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Hole(isTerm, idx, args) =>
           val reifiedArgs = args.map { arg =>
-            if (arg.isTerm) (using qctx: Quotes) => new ExprImpl(arg, QuotesImpl.scopeId)
+            if (arg.isTerm) (using q: Quotes) => new ExprImpl(arg, QuotesImpl.scopeId)
             else new TypeImpl(arg, QuotesImpl.scopeId)
           }
           if isTerm then

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

@@ -14,7 +14,7 @@ final class TypeImpl(val typeTree: tpd.Tree, val scopeId: Int) extends Type[?] {
   }
 
   /** View this expression `quoted.Type[T]` as a `TypeTree` */
-  def unseal(using qctx: Quotes): qctx.reflect.TypeTree =
+  def unseal(using Quotes): qctx.reflect.TypeTree =
     checkScopeId(qctx.hashCode)
     typeTree.asInstanceOf[qctx.reflect.TypeTree]
 

compiler/test-resources/repl-macros/i5551

@@ -1,8 +1,8 @@
 scala> import scala.quoted._
-scala> def assertImpl(expr: Expr[Boolean])(using qctx: Quotes) = '{ if !($expr) then throw new AssertionError("failed assertion")}
+scala> def assertImpl(expr: Expr[Boolean])(using q: Quotes) = '{ if !($expr) then throw new AssertionError("failed assertion")}
 def assertImpl
   (expr: quoted.Expr[Boolean])
-     (using qctx: quoted.Quotes): quoted.Expr[Unit]
+     (using q: quoted.Quotes): quoted.Expr[Unit]
 scala>   inline def assert(expr: => Boolean): Unit =  ${ assertImpl('{expr}) }
 def assert(expr: => Boolean): Unit
 

docs/docs/reference/contextual/derivation-macro.md

@@ -25,7 +25,7 @@ we need to implement a method `Eq.derived` on the companion object of `Eq` that
 produces a quoted instance for `Eq[T]`. Here is a possible signature,
 
 ```scala
-given derived[T: Type](using qctx: Quotes) as Expr[Eq[T]]
+given derived[T: Type](using Quotes) as Expr[Eq[T]]
 ```
 
 and for comparison reasons we give the same signature we had with `inline`:
@@ -41,7 +41,7 @@ from the signature. The body of the `derived` method is shown below:
 
 
 ```scala
-given derived[T: Type](using qctx: Quotes) as Expr[Eq[T]] = {
+given derived[T: Type](using Quotes) as Expr[Eq[T]] = {
   import qctx.reflect._
 
   val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
@@ -91,7 +91,7 @@ The implementation of `summonAll` as a macro can be show below assuming that we
 have the given instances for our primitive types:
 
 ```scala
-  def summonAll[T: Type](using qctx: Quotes): List[Expr[Eq[_]]] = Type.of[T] match {
+  def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] = Type.of[T] match {
     case '[String *: tpes] => '{ summon[Eq[String]] }  :: summonAll[tpes]
     case '[Int *: tpes]    => '{ summon[Eq[Int]] }     :: summonAll[tpes]
     case '[tpe *: tpes]   => derived[tpe] :: summonAll[tpes]
@@ -169,14 +169,14 @@ object Eq {
       def eqv(x: T, y: T): Boolean = body(x, y)
     }
 
-  def summonAll[T: Type](using qctx: Quotes): List[Expr[Eq[_]]] = Type.of[T] match {
+  def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] = Type.of[T] match {
     case '[String *: tpes] => '{ summon[Eq[String]] }  :: summonAll[tpes]
     case '[Int *: tpes]    => '{ summon[Eq[Int]] }     :: summonAll[tpes]
     case '[tpe *: tpes]   => derived[tpe] :: summonAll[tpes]
     case '[EmptyTuple] => Nil
   }
 
-  given derived[T: Type](using qctx: Quotes) as Expr[Eq[T]] = {
+  given derived[T: Type](using q: Quotes) as Expr[Eq[T]] = {
     import qctx.reflect._
 
     val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get

docs/docs/reference/metaprogramming/tasty-reflect.md

@@ -28,7 +28,7 @@ import scala.quoted._
 
 inline def natConst(inline x: Int): Int = ${natConstImpl('{x})}
 
-def natConstImpl(x: Expr[Int])(using qctx: Quotes): Expr[Int] = {
+def natConstImpl(x: Expr[Int])(using Quotes): Expr[Int] = {
   import qctx.reflect._
   ...
 }
@@ -40,7 +40,7 @@ def natConstImpl(x: Expr[Int])(using qctx: Quotes): Expr[Int] = {
 trees. For example the `Literal(_)` extractor used below.
 
 ```scala
-def natConstImpl(x: Expr[Int])(using qctx: Quotes): Expr[Int] = {
+def natConstImpl(x: Expr[Int])(using Quotes): Expr[Int] = {
   import qctx.reflect._
   val xTree: Term = Term.of(x)
   xTree match {

library/src-bootstrapped/scala/quoted/Expr.scala

@@ -13,7 +13,7 @@ object Expr {
    *   To retain semantics the argument `ei` is bound as `val yi = ei` and by-name arguments to `def yi = ei`.
    *   Some bindings may be elided as an early optimization.
    */
-  def betaReduce[T](expr: Expr[T])(using qctx: Quotes): Expr[T] =
+  def betaReduce[T](expr: Expr[T])(using Quotes): Expr[T] =
     import qctx.reflect._
     Term.betaReduce(Term.of(expr)) match
       case Some(expr1) => expr1.asExpr.asInstanceOf[Expr[T]]
@@ -23,13 +23,14 @@ object Expr {
    *  Given list of statements `s1 :: s2 :: ... :: Nil` and an expression `e` the resulting expression
    *  will be equivalent to `'{ $s1; $s2; ...; $e }`.
    */
-  def block[T](statements: List[Expr[Any]], expr: Expr[T])(using qctx: Quotes): Expr[T] = {
+  def block[T](statements: List[Expr[Any]], expr: Expr[T])(using Quotes): Expr[T] = {
     import qctx.reflect._
     Block(statements.map(Term.of), Term.of(expr)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Lift a value into an expression containing the construction of that value */
-  def apply[T](x: T)(using qctx: Quotes, lift: Liftable[T]): Expr[T] = lift.toExpr(x)
+  def apply[T](x: T)(using lift: Liftable[T])(using Quotes): Expr[T] =
+    lift.toExpr(x)
 
   /** Lifts this sequence of expressions into an expression of a sequence
    *
@@ -39,7 +40,8 @@ object Expr {
    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
    *  ```
    */
-  def ofSeq[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: Quotes): Expr[Seq[T]] = Varargs(xs)
+  def ofSeq[T](xs: Seq[Expr[T]])(using tp: Type[T], qctx: Quotes): Expr[Seq[T]] =
+    Varargs(xs)
 
   /** Lifts this list of expressions into an expression of a list
    *
@@ -48,7 +50,7 @@ object Expr {
    *  to an expression equivalent to
    *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
    */
-  def  ofList[T](xs: Seq[Expr[T]])(using Type[T], Quotes): Expr[List[T]] =
+  def  ofList[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[List[T]] =
     if (xs.isEmpty) Expr(Nil) else '{ List(${Varargs(xs)}: _*) }
 
   /** Lifts this sequence of expressions into an expression of a tuple
@@ -58,7 +60,7 @@ object Expr {
    *  to an expression equivalent to
    *    `'{ ($e1, $e2, ...) }` typed as an `Expr[Tuple]`
    */
-  def ofTupleFromSeq(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] = {
+  def ofTupleFromSeq(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = {
     seq.size match {
       case 0 => '{ Tuple() }
       case 1 => ofTupleFromSeq1(seq)
@@ -87,116 +89,116 @@ object Expr {
     }
   }
 
-  private def ofTupleFromSeq1(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq1(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }) => '{ Tuple1($x1) }
 
-  private def ofTupleFromSeq2(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq2(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }) => '{ Tuple2($x1, $x2) }
 
-  private def ofTupleFromSeq3(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq3(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }) => '{ Tuple3($x1, $x2, $x3) }
 
-  private def ofTupleFromSeq4(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq4(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }) =>
        '{ Tuple4($x1, $x2, $x3, $x4) }
 
-  private def ofTupleFromSeq5(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq5(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }) =>
         '{ Tuple5($x1, $x2, $x3, $x4, $x5) }
 
-  private def ofTupleFromSeq6(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq6(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }) =>
         '{ Tuple6($x1, $x2, $x3, $x4, $x5, $x6) }
 
-  private def ofTupleFromSeq7(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq7(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }) =>
         '{ Tuple7($x1, $x2, $x3, $x4, $x5, $x6, $x7) }
 
-  private def ofTupleFromSeq8(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq8(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }) =>
         '{ Tuple8($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8) }
 
-  private def ofTupleFromSeq9(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq9(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }) =>
         '{ Tuple9($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9) }
 
-  private def ofTupleFromSeq10(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq10(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }) =>
         '{ Tuple10($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10) }
 
-  private def ofTupleFromSeq11(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq11(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }) =>
         '{ Tuple11($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11) }
 
-  private def ofTupleFromSeq12(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq12(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }) =>
         '{ Tuple12($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12) }
 
-  private def ofTupleFromSeq13(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq13(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }) =>
         '{ Tuple13($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13) }
 
-  private def ofTupleFromSeq14(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq14(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }) =>
         '{ Tuple14($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14) }
 
-  private def ofTupleFromSeq15(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq15(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }) =>
         '{ Tuple15($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15) }
 
-  private def ofTupleFromSeq16(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq16(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }) =>
         '{ Tuple16($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16) }
 
-  private def ofTupleFromSeq17(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq17(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }) =>
         '{ Tuple17($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17) }
 
-  private def ofTupleFromSeq18(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq18(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }) =>
         '{ Tuple18($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18) }
 
-  private def ofTupleFromSeq19(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq19(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }, '{ $x19: t19 }) =>
         '{ Tuple19($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19) }
 
-  private def ofTupleFromSeq20(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq20(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }, '{ $x19: t19 }, '{ $x20: t20 }) =>
         '{ Tuple20($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20) }
 
-  private def ofTupleFromSeq21(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq21(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }, '{ $x19: t19 }, '{ $x20: t20 }, '{ $x21: t21 }) =>
         '{ Tuple21($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20, $x21) }
 
-  private def ofTupleFromSeq22(seq: Seq[Expr[Any]])(using qctx: Quotes): Expr[Tuple] =
+  private def ofTupleFromSeq22(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
     seq match
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }, '{ $x19: t19 }, '{ $x20: t20 }, '{ $x21: t21 }, '{ $x22: t22 }) =>
         '{ Tuple22($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20, $x21, $x22) }
 
 
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */
-  def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using qctx: Quotes): Expr[Tuple.InverseMap[T, Expr]] = {
+  def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using Quotes): Expr[Tuple.InverseMap[T, Expr]] = {
     val elems: Seq[Expr[Any]] = tup.asInstanceOf[Product].productIterator.toSeq.asInstanceOf[Seq[Expr[Any]]]
     ofTupleFromSeq(elems).asExprOf[Tuple.InverseMap[T, Expr]]
   }
@@ -209,7 +211,7 @@ object Expr {
    *  @param tpe quoted type of the implicit parameter
    *  @param qctx current context
    */
-  def summon[T](using tpe: Type[T])(using qctx: Quotes): Option[Expr[T]] = {
+  def summon[T](using Type[T])(using Quotes): Option[Expr[T]] = {
     import qctx.reflect._
     Implicits.search(TypeRepr.of[T]) match {
       case iss: ImplicitSearchSuccess => Some(iss.tree.asExpr.asInstanceOf[Expr[T]])

library/src-bootstrapped/scala/quoted/ExprMap.scala

@@ -2,11 +2,11 @@ package scala.quoted
 
 trait ExprMap:
 
-  /** Map an expression `e` with a type `tpe` */
-  def transform[T](e: Expr[T])(using qctx: Quotes, tpe: Type[T]): Expr[T]
+  /** Map an expression `e` with a type `T` */
+  def transform[T](e: Expr[T])(using Quotes, Type[T]): Expr[T]
 
-  /** Map subexpressions an expression `e` with a type `tpe` */
-  def transformChildren[T](e: Expr[T])(using qctx: Quotes, tpe: Type[T]): Expr[T] = {
+  /** Map subexpressions an expression `e` with a type `T` */
+  def transformChildren[T](e: Expr[T])(using Quotes, Type[T]): Expr[T] = {
     import qctx.reflect._
     final class MapChildren() {
 

library/src-bootstrapped/scala/quoted/Type.scala

@@ -12,11 +12,11 @@ end Type
 object Type:
 
   /** Show a source code like representation of this type without syntax highlight */
-  def show[T](using tp: Type[T])(using qctx: Quotes): String =
+  def show[T](using Type[T])(using Quotes): String =
     qctx.reflect.TypeTree.of[T].show
 
   /** Shows the tree as fully typed source code colored with ANSI */
-  def showAnsiColored[T](using tp: Type[T])(using qctx: Quotes): String =
+  def showAnsiColored[T](using Type[T])(using Quotes): String =
     qctx.reflect.TypeTree.of[T].showAnsiColored
 
   /** Return a quoted.Type with the given type */

library/src/scala/quoted/Const.scala

@@ -14,7 +14,7 @@ object Const {
    *  }
    *  ```
    */
-  def unapply[T](expr: Expr[T])(using qctx: Quotes): Option[T] = {
+  def unapply[T](expr: Expr[T])(using Quotes): Option[T] = {
     import qctx.reflect._
     def rec(tree: Term): Option[T] = tree match {
       case Literal(c) => Some(c.value.asInstanceOf[T])

library/src/scala/quoted/Consts.scala

@@ -15,7 +15,7 @@ object Consts {
    *  }
    *  ```
    */
-  def unapply[T](exprs: Seq[Expr[T]])(using qctx: Quotes): Option[Seq[T]] =
+  def unapply[T](exprs: Seq[Expr[T]])(using Quotes): Option[Seq[T]] =
     exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
       (elem, acc) match {
         case (Const(value), Some(lst)) => Some(value :: lst)