From 53d283fb20a8d99d856ca333413bf3af2b100601 Mon Sep 17 00:00:00 2001 From: Nicolas Stucki Date: Thu, 26 Nov 2020 18:13:46 +0100 Subject: [PATCH] Add names to `using` parameters for cleaner docs --- .../src-bootstrapped/scala/quoted/Expr.scala | 62 +++++++++---------- library/src/scala/quoted/ExprMap.scala | 4 +- library/src/scala/quoted/Quotes.scala | 14 ++--- library/src/scala/quoted/Type.scala | 4 +- library/src/scala/quoted/Unlifted.scala | 6 +- library/src/scala/quoted/Varargs.scala | 4 +- 6 files changed, 47 insertions(+), 47 deletions(-) diff --git a/library/src-bootstrapped/scala/quoted/Expr.scala b/library/src-bootstrapped/scala/quoted/Expr.scala index 9f4c6801abfc..fc7d47bc463f 100644 --- a/library/src-bootstrapped/scala/quoted/Expr.scala +++ b/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 Quotes): Expr[T] = + def betaReduce[T](expr: Expr[T])(using q: Quotes): Expr[T] = import quotes.reflect._ Term.betaReduce(Term.of(expr)) match case Some(expr1) => expr1.asExpr.asInstanceOf[Expr[T]] @@ -23,13 +23,13 @@ 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 Quotes): Expr[T] = { + def block[T](statements: List[Expr[Any]], expr: Expr[T])(using q: Quotes): Expr[T] = { import quotes.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 lift: Liftable[T])(using Quotes): Expr[T] = + def apply[T](x: T)(using lift: Liftable[T])(using q: Quotes): Expr[T] = lift.toExpr(x) /** Lifts this sequence of expressions into an expression of a sequence @@ -40,7 +40,7 @@ object Expr { * `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]` * ``` */ - def ofSeq[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] = + def ofSeq[T](xs: Seq[Expr[T]])(using Type[T])(using q: Quotes): Expr[Seq[T]] = Varargs(xs) /** Lifts this list of expressions into an expression of a list @@ -50,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])(using Quotes): Expr[List[T]] = + def ofList[T](xs: Seq[Expr[T]])(using Type[T])(using q: Quotes): Expr[List[T]] = if (xs.isEmpty) Expr(Nil) else '{ List(${Varargs(xs)}: _*) } /** Lifts this sequence of expressions into an expression of a tuple @@ -60,7 +60,7 @@ object Expr { * to an expression equivalent to * `'{ ($e1, $e2, ...) }` typed as an `Expr[Tuple]` */ - def ofTupleFromSeq(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = { + def ofTupleFromSeq(seq: Seq[Expr[Any]])(using q: Quotes): Expr[Tuple] = { seq.size match { case 0 => '{ Tuple() } case 1 => ofTupleFromSeq1(seq) @@ -89,116 +89,116 @@ object Expr { } } - private def ofTupleFromSeq1(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = + private def ofTupleFromSeq1(seq: Seq[Expr[Any]])(using q: Quotes): Expr[Tuple] = seq match case Seq('{ $x1: t1 }) => '{ Tuple1($x1) } - private def ofTupleFromSeq2(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = + private def ofTupleFromSeq2(seq: Seq[Expr[Any]])(using q: Quotes): Expr[Tuple] = seq match case Seq('{ $x1: t1 }, '{ $x2: t2 }) => '{ Tuple2($x1, $x2) } - private def ofTupleFromSeq3(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = + private def ofTupleFromSeq3(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq4(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq5(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq6(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq7(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq8(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq9(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq10(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq11(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq12(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq13(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq14(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq15(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq16(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq17(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq18(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq19(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq20(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq21(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple] = + private def ofTupleFromSeq22(seq: Seq[Expr[Any]])(using q: 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 Quotes): Expr[Tuple.InverseMap[T, Expr]] = { + def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]](tup: T)(using t: Type[T])(using q: 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 +209,7 @@ object Expr { * * @tparam T type of the implicit parameter */ - def summon[T](using Type[T])(using Quotes): Option[Expr[T]] = { + def summon[T](using Type[T])(using q: Quotes): Option[Expr[T]] = { import quotes.reflect._ Implicits.search(TypeRepr.of[T]) match { case iss: ImplicitSearchSuccess => Some(iss.tree.asExpr.asInstanceOf[Expr[T]]) @@ -221,7 +221,7 @@ object Expr { /** Matches a `StringContext(part0, part1, ...)` and extracts the parts of a call to if the * parts are passed explicitly. Returns the equvalent to `Seq('{part0}, '{part1}, ...)`. */ - def unapply(sc: Expr[StringContext])(using Quotes): Option[Seq[Expr[String]]] = + def unapply(sc: Expr[StringContext])(using q: Quotes): Option[Seq[Expr[String]]] = sc match case '{ scala.StringContext(${Varargs(parts)}: _*) } => Some(parts) case '{ new scala.StringContext(${Varargs(parts)}: _*) } => Some(parts) diff --git a/library/src/scala/quoted/ExprMap.scala b/library/src/scala/quoted/ExprMap.scala index b6064f238a2e..205ae03a0d2e 100644 --- a/library/src/scala/quoted/ExprMap.scala +++ b/library/src/scala/quoted/ExprMap.scala @@ -3,10 +3,10 @@ package scala.quoted trait ExprMap: /** Map an expression `e` with a type `T` */ - def transform[T](e: Expr[T])(using Quotes, Type[T]): Expr[T] + def transform[T](e: Expr[T])(using q: Quotes, t: 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] = { + def transformChildren[T](e: Expr[T])(using q: Quotes, t: Type[T]): Expr[T] = { import quotes.reflect._ final class MapChildren() { diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala index 17eabebd3af0..a880baca07cd 100644 --- a/library/src/scala/quoted/Quotes.scala +++ b/library/src/scala/quoted/Quotes.scala @@ -38,7 +38,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Returns `None` if the expression does not contain a value or contains side effects. * Otherwise returns the `Some` of the value. */ - def unlift(using Unliftable[T]): Option[T] = + def unlift(using u: Unliftable[T]): Option[T] = summon[Unliftable[T]].fromExpr(self)(using Quotes.this) /** Return the unlifted value of this expression. @@ -46,7 +46,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => * Emits an error and throws if the expression does not contain a value or contains side effects. * Otherwise returns the value. */ - def unliftOrError(using Unliftable[T]): T = + def unliftOrError(using u: Unliftable[T]): T = def reportError = val msg = s"Expected a known value. \n\nThe value of: ${self.show}\ncould not be unlifted using $unlift" reflect.report.throwError(msg, self) @@ -57,10 +57,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => // Extension methods for `Expr[Any]` that take another explicit type parameter extension [X](self: Expr[Any]): /** Checks is the `quoted.Expr[?]` is valid expression of type `X` */ - def isExprOf(using Type[X]): Boolean + def isExprOf(using t: Type[X]): Boolean /** Convert this to an `quoted.Expr[X]` if this expression is a valid expression of type `X` or throws */ - def asExprOf(using Type[X]): Expr[X] + def asExprOf(using t: Type[X]): Expr[X] end extension /** Low-level Typed AST API metaprogramming API. @@ -230,7 +230,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Convert this tree to an `quoted.Expr[T]` if the tree is a valid expression or throws */ extension [T](self: Tree) - def asExprOf(using Type[T]): Expr[T] + def asExprOf(using t: Type[T]): Expr[T] extension [ThisTree <: Tree](self: ThisTree): /** Changes the owner of the symbols in the tree */ @@ -1514,7 +1514,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypeTree` */ trait TypeTreeModule { this: TypeTree.type => /** Returns the tree of type or kind (TypeTree) of T */ - def of[T <: AnyKind](using Type[T]): TypeTree + def of[T <: AnyKind](using t: Type[T]): TypeTree } /** Makes extension methods on `TypeTree` available without any imports */ @@ -2341,7 +2341,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching => /** Methods of the module object `val TypeRepr` */ trait TypeReprModule { this: TypeRepr.type => /** Returns the type or kind (TypeRepr) of T */ - def of[T <: AnyKind](using Type[T]): TypeRepr + def of[T <: AnyKind](using t: Type[T]): TypeRepr /** Returns the type constructor of the runtime (erased) class */ def typeConstructorOf(clazz: Class[?]): TypeRepr diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala index 799314a5a64d..f3ee2e8a8b1b 100644 --- a/library/src/scala/quoted/Type.scala +++ b/library/src/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 Type[T])(using Quotes): String = + def show[T](using t: Type[T])(using q: Quotes): String = quotes.reflect.TypeTree.of[T].show /** Shows the tree as fully typed source code colored with ANSI */ - def showAnsiColored[T](using Type[T])(using Quotes): String = + def showAnsiColored[T](using t: Type[T])(using q: Quotes): String = quotes.reflect.TypeTree.of[T].showAnsiColored /** Return a quoted.Type with the given type */ diff --git a/library/src/scala/quoted/Unlifted.scala b/library/src/scala/quoted/Unlifted.scala index d19bbcc8bf3e..80128523ab40 100644 --- a/library/src/scala/quoted/Unlifted.scala +++ b/library/src/scala/quoted/Unlifted.scala @@ -12,8 +12,8 @@ object Unlifted { * } * ``` */ - def unapply[T](expr: Expr[T])(using Unliftable[T])(using Quotes): Option[T] = - summon[Unliftable[T]].fromExpr(expr) + def unapply[T](expr: Expr[T])(using u: Unliftable[T])(using q: Quotes): Option[T] = + u.fromExpr(expr) /** Matches literal sequence of literal constant value expressions and return a sequence of values. * @@ -27,7 +27,7 @@ object Unlifted { * } * ``` */ - def unapply[T](exprs: Seq[Expr[T]])(using unlift: Unliftable[T], qctx: Quotes): Option[Seq[T]] = + def unapply[T](exprs: Seq[Expr[T]])(using u: Unliftable[T], q: Quotes): Option[Seq[T]] = exprs.foldRight(Option(List.empty[T])) { (elem, acc) => (elem, acc) match { case (Unlifted(value), Some(lst)) => Some(value :: lst) diff --git a/library/src/scala/quoted/Varargs.scala b/library/src/scala/quoted/Varargs.scala index f26c4c20f7cb..09fd4744fc44 100644 --- a/library/src/scala/quoted/Varargs.scala +++ b/library/src/scala/quoted/Varargs.scala @@ -15,7 +15,7 @@ object Varargs { * '{ List(${Varargs(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) } * ``` */ - def apply[T](xs: Seq[Expr[T]])(using Type[T])(using Quotes): Expr[Seq[T]] = { + def apply[T](xs: Seq[Expr[T]])(using t: Type[T])(using q: Quotes): Expr[Seq[T]] = { import quotes.reflect._ Repeated(xs.map(Term.of).toList, TypeTree.of[T]).asExpr.asInstanceOf[Expr[Seq[T]]] } @@ -32,7 +32,7 @@ object Varargs { * } * ``` */ - def unapply[T](expr: Expr[Seq[T]])(using Quotes): Option[Seq[Expr[T]]] = { + def unapply[T](expr: Expr[Seq[T]])(using q: Quotes): Option[Seq[Expr[T]]] = { import quotes.reflect._ def rec(tree: Term): Option[Seq[Expr[T]]] = tree match { case Typed(Repeated(elems, _), _) => Some(elems.map(x => x.asExpr.asInstanceOf[Expr[T]]))