diff --git a/library/src/scala/quoted/Liftable.scala b/library/src/scala/quoted/Liftable.scala
index cdcacdbda1f7..ef2a71047e70 100644
--- a/library/src/scala/quoted/Liftable.scala
+++ b/library/src/scala/quoted/Liftable.scala
@@ -103,7 +103,7 @@ object Liftable {
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
-  given iArrayIsLiftable[T: Type](using ltArray: Liftable[Array[T]]): Liftable[IArray[T]] {
+  given iArrayIsLiftable[T: Type](using ltArray: Liftable[Array[T]]) as Liftable[IArray[T]] {
     def toExpr(iarray: IArray[T]): QuoteContext ?=> Expr[IArray[T]] =
       '{ ${ltArray.toExpr(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] }
   }
diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala
index 67292ea2b271..465070c400c3 100644
--- a/library/src/scala/quoted/Type.scala
+++ b/library/src/scala/quoted/Type.scala
@@ -17,47 +17,47 @@ class Type[T <: AnyKind] private[scala] {
 /** Some basic type tags, currently incomplete */
 object Type {
 
-  given UnitTag(using qctx: QuoteContext): Type[Unit] = {
+  given UnitTag(using qctx: QuoteContext) as Type[Unit] = {
     import qctx.tasty.{_, given}
     defn.UnitType.seal.asInstanceOf[quoted.Type[Unit]]
   }
 
-  given BooleanTag(using qctx: QuoteContext): Type[Boolean] = {
+  given BooleanTag(using qctx: QuoteContext) as Type[Boolean] = {
     import qctx.tasty.{_, given}
     defn.BooleanType.seal.asInstanceOf[quoted.Type[Boolean]]
   }
 
-  given ByteTag(using qctx: QuoteContext): Type[Byte] = {
+  given ByteTag(using qctx: QuoteContext) as Type[Byte] = {
     import qctx.tasty.{_, given}
     defn.ByteType.seal.asInstanceOf[quoted.Type[Byte]]
   }
 
-  given CharTag(using qctx: QuoteContext): Type[Char] = {
+  given CharTag(using qctx: QuoteContext) as Type[Char] = {
     import qctx.tasty.{_, given}
     defn.CharType.seal.asInstanceOf[quoted.Type[Char]]
   }
 
-  given ShortTag(using qctx: QuoteContext): Type[Short] = {
+  given ShortTag(using qctx: QuoteContext) as Type[Short] = {
     import qctx.tasty.{_, given}
     defn.ShortType.seal.asInstanceOf[quoted.Type[Short]]
   }
 
-  given IntTag(using qctx: QuoteContext): Type[Int] = {
+  given IntTag(using qctx: QuoteContext) as Type[Int] = {
     import qctx.tasty.{_, given}
     defn.IntType.seal.asInstanceOf[quoted.Type[Int]]
   }
 
-  given LongTag(using qctx: QuoteContext): Type[Long] = {
+  given LongTag(using qctx: QuoteContext) as Type[Long] = {
     import qctx.tasty.{_, given}
     defn.LongType.seal.asInstanceOf[quoted.Type[Long]]
   }
 
-  given FloatTag(using qctx: QuoteContext): Type[Float] = {
+  given FloatTag(using qctx: QuoteContext) as Type[Float] = {
     import qctx.tasty.{_, given}
     defn.FloatType.seal.asInstanceOf[quoted.Type[Float]]
   }
 
-  given DoubleTag(using qctx: QuoteContext): Type[Double] = {
+  given DoubleTag(using qctx: QuoteContext) as Type[Double] = {
     import qctx.tasty.{_, given}
     defn.DoubleType.seal.asInstanceOf[quoted.Type[Double]]
   }
diff --git a/library/src/scala/quoted/ValueOfExpr.scala b/library/src/scala/quoted/ValueOfExpr.scala
index 0a6348653cdb..a0d7b7f3f4cd 100644
--- a/library/src/scala/quoted/ValueOfExpr.scala
+++ b/library/src/scala/quoted/ValueOfExpr.scala
@@ -32,7 +32,7 @@ object ValueOfExpr {
     def apply(x: Expr[T])(using qctx: QuoteContext): Option[T] = matching.Const.unapply(x)
   }
 
-  given Option_delegate[T](using Type[T], ValueOfExpr[T]): ValueOfExpr[Option[T]] = new {
+  given Option_delegate[T](using Type[T], ValueOfExpr[T]) as ValueOfExpr[Option[T]] = new {
     def apply(x: Expr[Option[T]])(using qctx: QuoteContext): Option[Option[T]] = x match {
       case '{ None: Option[T] } => Some(None) // FIXME: remove ascription, Matcher should be able to match this expression
       case '{ new Some[T](${Value(y)}) } => Some(Some(y))
@@ -52,7 +52,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple1_delegate[T1](using Type[T1], ValueOfExpr[T1]): ValueOfExpr[Tuple1[T1]] = new {
+  given Tuple1_delegate[T1](using Type[T1], ValueOfExpr[T1]) as ValueOfExpr[Tuple1[T1]] = new {
     def apply(x: Expr[Tuple1[T1]])(using qctx: QuoteContext): Option[Tuple1[T1]] = x match {
       case '{ new Tuple1[T1](${Value(y)}) } => Some(Tuple1(y))
       case '{     Tuple1[T1](${Value(y)}) } => Some(Tuple1(y))
@@ -61,7 +61,7 @@ object ValueOfExpr {
     override def toString(): String = "scala.quoted.ValueOfExpr.Tuple1_delegate"
   }
 
-  given Tuple2_delegate[T1, T2](using Type[T1], Type[T2], ValueOfExpr[T1], ValueOfExpr[T2]): ValueOfExpr[Tuple2[T1, T2]] = new {
+  given Tuple2_delegate[T1, T2](using Type[T1], Type[T2], ValueOfExpr[T1], ValueOfExpr[T2]) as ValueOfExpr[Tuple2[T1, T2]] = new {
     def apply(x: Expr[Tuple2[T1, T2]])(using qctx: QuoteContext): Option[Tuple2[T1, T2]] = x match {
       case '{ new Tuple2[T1, T2](${Value(y1)}, ${Value(y2)}) } => Some(Tuple2(y1, y2))
       case '{     Tuple2[T1, T2](${Value(y1)}, ${Value(y2)}) } => Some(Tuple2(y1, y2))
@@ -71,7 +71,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple3_delegate[T1, T2, T3](using Type[T1], Type[T2], Type[T3], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3]): ValueOfExpr[Tuple3[T1, T2, T3]] = new {
+  given Tuple3_delegate[T1, T2, T3](using Type[T1], Type[T2], Type[T3], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3]) as ValueOfExpr[Tuple3[T1, T2, T3]] = new {
     def apply(x: Expr[Tuple3[T1, T2, T3]])(using qctx: QuoteContext): Option[Tuple3[T1, T2, T3]] = x match {
       case '{ new Tuple3[T1, T2, T3](${Value(y1)}, ${Value(y2)}, ${Value(y3)}) } => Some(Tuple3(y1, y2, y3))
       case '{     Tuple3[T1, T2, T3](${Value(y1)}, ${Value(y2)}, ${Value(y3)}) } => Some(Tuple3(y1, y2, y3))
@@ -81,7 +81,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple4_delegate[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4]): ValueOfExpr[Tuple4[T1, T2, T3, T4]] = new {
+  given Tuple4_delegate[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4]) as ValueOfExpr[Tuple4[T1, T2, T3, T4]] = new {
     def apply(x: Expr[Tuple4[T1, T2, T3, T4]])(using qctx: QuoteContext): Option[Tuple4[T1, T2, T3, T4]] = x match {
       case '{ new Tuple4[T1, T2, T3, T4](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}) } => Some(Tuple4(y1, y2, y3, y4))
       case '{     Tuple4[T1, T2, T3, T4](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}) } => Some(Tuple4(y1, y2, y3, y4))
@@ -91,7 +91,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple5_delegate[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5]): ValueOfExpr[Tuple5[T1, T2, T3, T4, T5]] = new {
+  given Tuple5_delegate[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5]) as ValueOfExpr[Tuple5[T1, T2, T3, T4, T5]] = new {
     def apply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using qctx: QuoteContext): Option[Tuple5[T1, T2, T3, T4, T5]] = x match {
       case '{ new Tuple5[T1, T2, T3, T4, T5](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5))
       case '{     Tuple5[T1, T2, T3, T4, T5](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5))
@@ -101,7 +101,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple6_delegate[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6]): ValueOfExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
+  given Tuple6_delegate[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6]) as ValueOfExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
     def apply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using qctx: QuoteContext): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = x match {
       case '{ new Tuple6[T1, T2, T3, T4, T5, T6](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6))
       case '{     Tuple6[T1, T2, T3, T4, T5, T6](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6))
@@ -111,7 +111,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple7_delegate[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7]): ValueOfExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
+  given Tuple7_delegate[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7]) as ValueOfExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
     def apply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using qctx: QuoteContext): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = x match {
       case '{ new Tuple7[T1, T2, T3, T4, T5, T6, T7](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7))
       case '{     Tuple7[T1, T2, T3, T4, T5, T6, T7](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7))
@@ -121,7 +121,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple8_delegate[T1, T2, T3, T4, T5, T6, T7, T8](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8]): ValueOfExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
+  given Tuple8_delegate[T1, T2, T3, T4, T5, T6, T7, T8](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8]) as ValueOfExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
     def apply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using qctx: QuoteContext): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = x match {
       case '{ new Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8))
       case '{     Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8))
@@ -131,7 +131,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple9_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9]): ValueOfExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
+  given Tuple9_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9]) as ValueOfExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
     def apply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using qctx: QuoteContext): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = x match {
       case '{ new Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9))
       case '{     Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9))
@@ -141,7 +141,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple10_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10]): ValueOfExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
+  given Tuple10_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10]) as ValueOfExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
     def apply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using qctx: QuoteContext): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = x match {
       case '{ new Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10))
       case '{     Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10))
@@ -151,7 +151,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple11_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11]): ValueOfExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
+  given Tuple11_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11]) as ValueOfExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
     def apply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using qctx: QuoteContext): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = x match {
       case '{ new Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11))
       case '{     Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11))
@@ -161,7 +161,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple12_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12]): ValueOfExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
+  given Tuple12_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12]) as ValueOfExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
     def apply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using qctx: QuoteContext): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = x match {
       case '{ new Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12))
       case '{     Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12))
@@ -171,7 +171,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple13_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13]): ValueOfExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
+  given Tuple13_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13]) as ValueOfExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
     def apply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using qctx: QuoteContext): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = x match {
       case '{ new Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13))
       case '{     Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13))
@@ -181,7 +181,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple14_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14]): ValueOfExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
+  given Tuple14_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14]) as ValueOfExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
     def apply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using qctx: QuoteContext): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = x match {
       case '{ new Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14))
       case '{     Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14))
@@ -191,7 +191,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple15_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15]): ValueOfExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
+  given Tuple15_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15]) as ValueOfExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
     def apply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using qctx: QuoteContext): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = x match {
       case '{ new Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15))
       case '{     Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15))
@@ -201,7 +201,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple16_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16]): ValueOfExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
+  given Tuple16_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16]) as ValueOfExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
     def apply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using qctx: QuoteContext): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = x match {
       case '{ new Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16))
       case '{     Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16))
@@ -211,7 +211,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple17_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17]): ValueOfExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
+  given Tuple17_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17]) as ValueOfExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
     def apply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using qctx: QuoteContext): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = x match {
       case '{ new Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17))
       case '{     Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17))
@@ -221,7 +221,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple18_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18]): ValueOfExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
+  given Tuple18_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18]) as ValueOfExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
     def apply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using qctx: QuoteContext): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = x match {
       case '{ new Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18))
       case '{     Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18))
@@ -231,7 +231,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple19_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19]): ValueOfExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
+  given Tuple19_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19]) as ValueOfExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
     def apply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using qctx: QuoteContext): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = x match {
       case '{ new Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19))
       case '{     Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19))
@@ -241,7 +241,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple20_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20]): ValueOfExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
+  given Tuple20_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20]) as ValueOfExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
     def apply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using qctx: QuoteContext): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = x match {
       case '{ new Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20))
       case '{     Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20))
@@ -251,7 +251,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple21_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20], ValueOfExpr[T21]): ValueOfExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
+  given Tuple21_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20], ValueOfExpr[T21]) as ValueOfExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
     def apply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using qctx: QuoteContext): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = x match {
       case '{ new Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}, ${Value(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21))
       case '{     Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}, ${Value(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21))
@@ -261,7 +261,7 @@ object ValueOfExpr {
   }
 
 
-  given Tuple22_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], Type[T22], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20], ValueOfExpr[T21], ValueOfExpr[T22]): ValueOfExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new {
+  given Tuple22_delegate[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], Type[T22], ValueOfExpr[T1], ValueOfExpr[T2], ValueOfExpr[T3], ValueOfExpr[T4], ValueOfExpr[T5], ValueOfExpr[T6], ValueOfExpr[T7], ValueOfExpr[T8], ValueOfExpr[T9], ValueOfExpr[T10], ValueOfExpr[T11], ValueOfExpr[T12], ValueOfExpr[T13], ValueOfExpr[T14], ValueOfExpr[T15], ValueOfExpr[T16], ValueOfExpr[T17], ValueOfExpr[T18], ValueOfExpr[T19], ValueOfExpr[T20], ValueOfExpr[T21], ValueOfExpr[T22]) as ValueOfExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new {
     def apply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using qctx: QuoteContext): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = x match {
       case '{ new Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}, ${Value(y21)}, ${Value(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22))
       case '{     Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Value(y1)}, ${Value(y2)}, ${Value(y3)}, ${Value(y4)}, ${Value(y5)}, ${Value(y6)}, ${Value(y7)}, ${Value(y8)}, ${Value(y9)}, ${Value(y10)}, ${Value(y11)}, ${Value(y12)}, ${Value(y13)}, ${Value(y14)}, ${Value(y15)}, ${Value(y16)}, ${Value(y17)}, ${Value(y18)}, ${Value(y19)}, ${Value(y20)}, ${Value(y21)}, ${Value(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22))
@@ -270,7 +270,7 @@ object ValueOfExpr {
     override def toString(): String = "scala.quoted.ValueOfExpr.Tuple22_delegate"
   }
 
-  given Seq_delegate[T](using Type[T], ValueOfExpr[T]): ValueOfExpr[Seq[T]] = new {
+  given Seq_delegate[T](using Type[T], ValueOfExpr[T]) as ValueOfExpr[Seq[T]] = new {
     def apply(x: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] = x match {
       case ValueSeq(elems) => Some(elems)
       case '{ scala.collection.Seq[T](${ValueSeq(elems)}: _*) } => Some(elems)
diff --git a/library/src/scala/quoted/autolift.scala b/library/src/scala/quoted/autolift.scala
index 627986b6f697..986cbf13c7a3 100644
--- a/library/src/scala/quoted/autolift.scala
+++ b/library/src/scala/quoted/autolift.scala
@@ -3,5 +3,5 @@ package scala.quoted
 /** Enable implicit conversion from a term of type `T` to an expression of type `Expr[T]` */
 object autolift {
   /** Implicit conversion from a term of type `T` to an expression of type `Expr[T]` */
-  given autoToExpr[T](using Liftable[T], QuoteContext): Conversion[T, Expr[T]] = Expr(_)
+  given autoToExpr[T](using Liftable[T], QuoteContext) as Conversion[T, Expr[T]] = Expr(_)
 }
diff --git a/library/src/scala/tasty/Reflection.scala b/library/src/scala/tasty/Reflection.scala
index dfdf138bdb0c..1464fec492b6 100644
--- a/library/src/scala/tasty/Reflection.scala
+++ b/library/src/scala/tasty/Reflection.scala
@@ -503,7 +503,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       new SourceCodePrinter[self.type](self)(syntaxHighlight).showTree(tree)
   }
 
-  given (using ctx: Context): IsInstanceOf[PackageClause] = internal.isInstanceOfPackageClause
+  given (using ctx: Context) as IsInstanceOf[PackageClause] = internal.isInstanceOfPackageClause
 
   object PackageClause {
     def apply(pid: Ref, stats: List[Tree])(using ctx: Context): PackageClause =
@@ -519,7 +519,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def stats(using ctx: Context): List[Tree] = internal.PackageClause_stats(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Import] = internal.isInstanceOfImport
+  given (using ctx: Context) as IsInstanceOf[Import] = internal.isInstanceOfImport
 
   object Import {
     def apply(expr: Term, selectors: List[ImportSelector])(using ctx: Context): Import =
@@ -536,11 +536,11 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       internal.Import_selectors(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Statement] = internal.isInstanceOfStatement
+  given (using ctx: Context) as IsInstanceOf[Statement] = internal.isInstanceOfStatement
 
   // ----- Definitions ----------------------------------------------
 
-  given (using ctx: Context): IsInstanceOf[Definition] = internal.isInstanceOfDefinition
+  given (using ctx: Context) as IsInstanceOf[Definition] = internal.isInstanceOfDefinition
 
   extension DefinitionOps on (self: Definition) {
     def name(using ctx: Context): String = internal.Definition_name(self)
@@ -548,7 +548,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // ClassDef
 
-  given (using ctx: Context): IsInstanceOf[ClassDef] = internal.isInstanceOfClassDef
+  given (using ctx: Context) as IsInstanceOf[ClassDef] = internal.isInstanceOfClassDef
 
   object ClassDef {
     // TODO def apply(name: String, constr: DefDef, parents: List[TermOrTypeTree], selfOpt: Option[ValDef], body: List[Statement])(using ctx: Context): ClassDef
@@ -568,7 +568,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // DefDef
 
-  given (using ctx: Context): IsInstanceOf[DefDef] = internal.isInstanceOfDefDef
+  given (using ctx: Context) as IsInstanceOf[DefDef] = internal.isInstanceOfDefDef
 
   object DefDef {
     def apply(symbol: Symbol, rhsFn: List[Type] => List[List[Term]] => Option[Term])(using ctx: Context): DefDef =
@@ -588,7 +588,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // ValDef
 
-  given (using ctx: Context): IsInstanceOf[ValDef] = internal.isInstanceOfValDef
+  given (using ctx: Context) as IsInstanceOf[ValDef] = internal.isInstanceOfValDef
 
   object ValDef {
     def apply(symbol: Symbol, rhs: Option[Term])(using ctx: Context): ValDef =
@@ -606,7 +606,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // TypeDef
 
-  given (using ctx: Context): IsInstanceOf[TypeDef] = internal.isInstanceOfTypeDef
+  given (using ctx: Context) as IsInstanceOf[TypeDef] = internal.isInstanceOfTypeDef
 
   object TypeDef {
     def apply(symbol: Symbol)(using ctx: Context): TypeDef =
@@ -623,7 +623,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // PackageDef
 
-  given (using ctx: Context): IsInstanceOf[PackageDef] = internal.isInstanceOfPackageDef
+  given (using ctx: Context) as IsInstanceOf[PackageDef] = internal.isInstanceOfPackageDef
 
   extension PackageDefOps on (self: PackageDef) {
     def owner(using ctx: Context): PackageDef = internal.PackageDef_owner(self)
@@ -682,9 +682,9 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def select(sym: Symbol)(using ctx: Context): Select = Select(self, sym)
   }
 
-  given (using ctx: Context): IsInstanceOf[Term] = internal.isInstanceOfTerm
+  given (using ctx: Context) as IsInstanceOf[Term] = internal.isInstanceOfTerm
 
-  given (using ctx: Context): IsInstanceOf[Ref] = internal.isInstanceOfRef
+  given (using ctx: Context) as IsInstanceOf[Ref] = internal.isInstanceOfRef
 
   object Ref {
 
@@ -706,7 +706,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       internal.Ref_apply(sym)
   }
 
-  given (using ctx: Context): IsInstanceOf[Ident] = internal.isInstanceOfIdent
+  given (using ctx: Context) as IsInstanceOf[Ident] = internal.isInstanceOfIdent
 
   extension IdentOps on (self: Ident) {
     def name(using ctx: Context): String = internal.Ident_name(self)
@@ -725,7 +725,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       Some(tree.name)
   }
 
-  given (using ctx: Context): IsInstanceOf[Select] = internal.isInstanceOfSelect
+  given (using ctx: Context) as IsInstanceOf[Select] = internal.isInstanceOfSelect
 
   /** Scala term selection */
   object Select {
@@ -761,7 +761,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def signature(using ctx: Context): Option[Signature] = internal.Select_signature(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Literal] =
+  given (using ctx: Context) as IsInstanceOf[Literal] =
     internal.isInstanceOfLiteral
 
   /** Scala literal constant */
@@ -783,7 +783,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def constant(using ctx: Context): Constant = internal.Literal_constant(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[This] = internal.isInstanceOfThis
+  given (using ctx: Context) as IsInstanceOf[This] = internal.isInstanceOfThis
 
   /** Scala `this` or `this[id]` */
   object This {
@@ -804,7 +804,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def id(using ctx: Context): Option[Id] = internal.This_id(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[New] = internal.isInstanceOfNew
+  given (using ctx: Context) as IsInstanceOf[New] = internal.isInstanceOfNew
 
   /** Scala `new` */
   object New {
@@ -824,7 +824,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def tpt(using ctx: Context): TypeTree = internal.New_tpt(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[NamedArg] = internal.isInstanceOfNamedArg
+  given (using ctx: Context) as IsInstanceOf[NamedArg] = internal.isInstanceOfNamedArg
 
   /** Scala named argument `x = y` in argument position */
   object NamedArg {
@@ -847,7 +847,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def value(using ctx: Context): Term = internal.NamedArg_value(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Apply] = internal.isInstanceOfApply
+  given (using ctx: Context) as IsInstanceOf[Apply] = internal.isInstanceOfApply
 
   /** Scala parameter application */
   object Apply {
@@ -869,7 +869,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def args(using ctx: Context): List[Term] = internal.Apply_args(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeApply] = internal.isInstanceOfTypeApply
+  given (using ctx: Context) as IsInstanceOf[TypeApply] = internal.isInstanceOfTypeApply
 
   /** Scala type parameter application */
   object TypeApply {
@@ -892,7 +892,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def args(using ctx: Context): List[TypeTree] = internal.TypeApply_args(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Super] = internal.isInstanceOfSuper
+  given (using ctx: Context) as IsInstanceOf[Super] = internal.isInstanceOfSuper
 
   /** Scala `x.super` or `x.super[id]` */
 
@@ -915,7 +915,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def id(using ctx: Context): Option[Id] = internal.Super_id(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Typed] = internal.isInstanceOfTyped
+  given (using ctx: Context) as IsInstanceOf[Typed] = internal.isInstanceOfTyped
 
   /** Scala ascription `x: T` */
   object Typed {
@@ -938,7 +938,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def tpt(using ctx: Context): TypeTree = internal.Typed_tpt(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Assign] = internal.isInstanceOfAssign
+  given (using ctx: Context) as IsInstanceOf[Assign] = internal.isInstanceOfAssign
 
   /** Scala assign `x = y` */
   object Assign {
@@ -960,7 +960,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def rhs(using ctx: Context): Term = internal.Assign_rhs(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Block] = internal.isInstanceOfBlock
+  given (using ctx: Context) as IsInstanceOf[Block] = internal.isInstanceOfBlock
 
   /** Scala code block `{ stat0; ...; statN; expr }` term */
 
@@ -983,7 +983,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def expr(using ctx: Context): Term = internal.Block_expr(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Closure] = internal.isInstanceOfClosure
+  given (using ctx: Context) as IsInstanceOf[Closure] = internal.isInstanceOfClosure
 
   object Closure {
 
@@ -1028,7 +1028,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   }
 
-  given (using ctx: Context): IsInstanceOf[If] = internal.isInstanceOfIf
+  given (using ctx: Context) as IsInstanceOf[If] = internal.isInstanceOfIf
 
   /** Scala `if`/`else` term */
   object If {
@@ -1052,7 +1052,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def elsep(using ctx: Context): Term = internal.If_elsep(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Match] = internal.isInstanceOfMatch
+  given (using ctx: Context) as IsInstanceOf[Match] = internal.isInstanceOfMatch
 
   /** Scala `match` term */
   object Match {
@@ -1075,7 +1075,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def cases(using ctx: Context): List[CaseDef] = internal.Match_cases(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[GivenMatch] = internal.isInstanceOfGivenMatch
+  given (using ctx: Context) as IsInstanceOf[GivenMatch] = internal.isInstanceOfGivenMatch
 
   /** Scala implicit `match` term */
 
@@ -1097,7 +1097,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def cases(using ctx: Context): List[CaseDef] = internal.GivenMatch_cases(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Try] = internal.isInstanceOfTry
+  given (using ctx: Context) as IsInstanceOf[Try] = internal.isInstanceOfTry
 
   /** Scala `try`/`catch`/`finally` term */
   object Try {
@@ -1121,7 +1121,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def finalizer(using ctx: Context): Option[Term] = internal.Try_finalizer(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Return] = internal.isInstanceOfReturn
+  given (using ctx: Context) as IsInstanceOf[Return] = internal.isInstanceOfReturn
 
   /** Scala local `return` */
   object Return {
@@ -1142,7 +1142,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def expr(using ctx: Context): Term = internal.Return_expr(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Repeated] = internal.isInstanceOfRepeated
+  given (using ctx: Context) as IsInstanceOf[Repeated] = internal.isInstanceOfRepeated
 
   object Repeated {
 
@@ -1162,7 +1162,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def elemtpt(using ctx: Context): TypeTree = internal.Repeated_elemtpt(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Inlined] = internal.isInstanceOfInlined
+  given (using ctx: Context) as IsInstanceOf[Inlined] = internal.isInstanceOfInlined
 
   object Inlined {
 
@@ -1183,7 +1183,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def body(using ctx: Context): Term = internal.Inlined_body(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[SelectOuter] = internal.isInstanceOfSelectOuter
+  given (using ctx: Context) as IsInstanceOf[SelectOuter] = internal.isInstanceOfSelectOuter
 
   object SelectOuter {
 
@@ -1203,7 +1203,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def level(using ctx: Context): Int = internal.SelectOuter_level(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[While] = internal.isInstanceOfWhile
+  given (using ctx: Context) as IsInstanceOf[While] = internal.isInstanceOfWhile
 
   object While {
 
@@ -1232,10 +1232,10 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def tpe(using ctx: Context): Type = internal.TypeTree_tpe(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeTree] =
+  given (using ctx: Context) as IsInstanceOf[TypeTree] =
     internal.isInstanceOfTypeTree
 
-  given (using ctx: Context): IsInstanceOf[Inferred] = internal.isInstanceOfInferred
+  given (using ctx: Context) as IsInstanceOf[Inferred] = internal.isInstanceOfInferred
 
   /** TypeTree containing an inferred type */
   object Inferred {
@@ -1245,7 +1245,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def unapply(x: Inferred)(using ctx: Context): Boolean = true
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeIdent] = internal.isInstanceOfTypeIdent
+  given (using ctx: Context) as IsInstanceOf[TypeIdent] = internal.isInstanceOfTypeIdent
 
   extension TypeIdentOps on (self: TypeIdent) {
     def name(using ctx: Context): String = internal.TypeIdent_name(self)
@@ -1259,7 +1259,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def unapply(x: TypeIdent)(using ctx: Context): Option[String] = Some(x.name)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeSelect] = internal.isInstanceOfTypeSelect
+  given (using ctx: Context) as IsInstanceOf[TypeSelect] = internal.isInstanceOfTypeSelect
 
   object TypeSelect {
     def apply(qualifier: Term, name: String)(using ctx: Context): TypeSelect =
@@ -1275,7 +1275,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def name(using ctx: Context): String = internal.TypeSelect_name(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Projection] = internal.isInstanceOfProjection
+  given (using ctx: Context) as IsInstanceOf[Projection] = internal.isInstanceOfProjection
 
   object Projection {
     // TODO def apply(qualifier: TypeTree, name: String)(using ctx: Context): Project
@@ -1290,7 +1290,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def name(using ctx: Context): String = internal.Projection_name(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Singleton] = internal.isInstanceOfSingleton
+  given (using ctx: Context) as IsInstanceOf[Singleton] = internal.isInstanceOfSingleton
 
   object Singleton {
     def apply(ref: Term)(using ctx: Context): Singleton =
@@ -1305,7 +1305,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def ref(using ctx: Context): Term = internal.Singleton_ref(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Refined] = internal.isInstanceOfRefined
+  given (using ctx: Context) as IsInstanceOf[Refined] = internal.isInstanceOfRefined
 
   object Refined {
     // TODO def apply(tpt: TypeTree, refinements: List[Definition])(using ctx: Context): Refined
@@ -1320,7 +1320,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def refinements(using ctx: Context): List[Definition] = internal.Refined_refinements(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Applied] = internal.isInstanceOfApplied
+  given (using ctx: Context) as IsInstanceOf[Applied] = internal.isInstanceOfApplied
 
   object Applied {
     def apply(tpt: TypeTree, args: List[Tree /*TypeTree | TypeBoundsTree*/])(using ctx: Context): Applied =
@@ -1336,7 +1336,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def args(using ctx: Context): List[Tree /*TypeTree | TypeBoundsTree*/] = internal.Applied_args(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Annotated] =
+  given (using ctx: Context) as IsInstanceOf[Annotated] =
     internal.isInstanceOfAnnotated
 
   object Annotated {
@@ -1353,7 +1353,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def annotation(using ctx: Context): Term = internal.Annotated_annotation(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[MatchTypeTree] =
+  given (using ctx: Context) as IsInstanceOf[MatchTypeTree] =
     internal.isInstanceOfMatchTypeTree
 
   object MatchTypeTree {
@@ -1371,7 +1371,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def cases(using ctx: Context): List[TypeCaseDef] = internal.MatchTypeTree_cases(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[ByName] =
+  given (using ctx: Context) as IsInstanceOf[ByName] =
     internal.isInstanceOfByName
 
   object ByName {
@@ -1387,7 +1387,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def result(using ctx: Context): TypeTree = internal.ByName_result(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[LambdaTypeTree] = internal.isInstanceOfLambdaTypeTree
+  given (using ctx: Context) as IsInstanceOf[LambdaTypeTree] = internal.isInstanceOfLambdaTypeTree
 
   object LambdaTypeTree {
     def apply(tparams: List[TypeDef], body: Tree /*TypeTree | TypeBoundsTree*/)(using ctx: Context): LambdaTypeTree =
@@ -1403,7 +1403,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def body(using ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = internal.Lambdabody(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeBind] = internal.isInstanceOfTypeBind
+  given (using ctx: Context) as IsInstanceOf[TypeBind] = internal.isInstanceOfTypeBind
 
   object TypeBind {
     // TODO def apply(name: String, tree: Tree)(using ctx: Context): TypeBind
@@ -1418,7 +1418,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def body(using ctx: Context): Tree /*TypeTree | TypeBoundsTree*/ = internal.TypeBind_body(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeBlock] = internal.isInstanceOfTypeBlock
+  given (using ctx: Context) as IsInstanceOf[TypeBlock] = internal.isInstanceOfTypeBlock
 
   object TypeBlock {
     def apply(aliases: List[TypeDef], tpt: TypeTree)(using ctx: Context): TypeBlock =
@@ -1442,7 +1442,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def hi(using ctx: Context): TypeTree = internal.TypeBoundsTree_hi(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeBoundsTree] = internal.isInstanceOfTypeBoundsTree
+  given (using ctx: Context) as IsInstanceOf[TypeBoundsTree] = internal.isInstanceOfTypeBoundsTree
 
   object TypeBoundsTree {
     def unapply(x: TypeBoundsTree)(using ctx: Context): Option[(TypeTree, TypeTree)] =
@@ -1453,7 +1453,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def tpe(using ctx: Context): TypeOrBounds = internal.WildcardTypeTree_tpe(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[WildcardTypeTree] = internal.isInstanceOfWildcardTypeTree
+  given (using ctx: Context) as IsInstanceOf[WildcardTypeTree] = internal.isInstanceOfWildcardTypeTree
 
   object WildcardTypeTree {
     /** Matches a TypeBoundsTree containing wildcard type bounds */
@@ -1468,7 +1468,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def rhs(using ctx: Context): Term = internal.CaseDef_rhs(caseDef)
   }
 
-  given (using ctx: Context): IsInstanceOf[CaseDef] = internal.isInstanceOfCaseDef
+  given (using ctx: Context) as IsInstanceOf[CaseDef] = internal.isInstanceOfCaseDef
 
   object CaseDef {
     def apply(pattern: Tree, guard: Option[Term], rhs: Term)(using ctx: Context): CaseDef =
@@ -1486,7 +1486,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def rhs(using ctx: Context): TypeTree = internal.TypeCaseDef_rhs(caseDef)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeCaseDef] =
+  given (using ctx: Context) as IsInstanceOf[TypeCaseDef] =
     internal.isInstanceOfTypeCaseDef
 
   object TypeCaseDef {
@@ -1502,7 +1502,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // ----- Patterns ------------------------------------------------
 
-  given (using ctx: Context): IsInstanceOf[Bind] = internal.isInstanceOfBind
+  given (using ctx: Context) as IsInstanceOf[Bind] = internal.isInstanceOfBind
 
   object Bind {
     // TODO def apply(name: String, pattern: Tree)(using ctx: Context): Bind
@@ -1517,7 +1517,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def pattern(using ctx: Context): Tree = internal.Tree_Bind_pattern(bind)
   }
 
-  given (using ctx: Context): IsInstanceOf[Unapply] = internal.isInstanceOfUnapply
+  given (using ctx: Context) as IsInstanceOf[Unapply] = internal.isInstanceOfUnapply
 
   object Unapply {
     // TODO def apply(fun: Term, implicits: List[Term], patterns: List[Tree])(using ctx: Context): Unapply
@@ -1533,7 +1533,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def patterns(using ctx: Context): List[Tree] = internal.Tree_Unapply_patterns(unapply)
   }
 
-  given (using ctx: Context): IsInstanceOf[Alternatives] = internal.isInstanceOfAlternatives
+  given (using ctx: Context) as IsInstanceOf[Alternatives] = internal.isInstanceOfAlternatives
 
   object Alternatives {
     def apply(patterns: List[Tree])(using ctx: Context): Alternatives =
@@ -1558,7 +1558,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       internal.SimpleSelector_selection(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[SimpleSelector] = internal.isInstanceOfSimpleSelector
+  given (using ctx: Context) as IsInstanceOf[SimpleSelector] = internal.isInstanceOfSimpleSelector
 
   object SimpleSelector
     def unapply(x: SimpleSelector)(using ctx: Context): Option[Id] = Some(x.selection)
@@ -1571,7 +1571,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       internal.RenameSelector_to(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[RenameSelector] = internal.isInstanceOfRenameSelector
+  given (using ctx: Context) as IsInstanceOf[RenameSelector] = internal.isInstanceOfRenameSelector
 
   object RenameSelector
     def unapply(x: RenameSelector)(using ctx: Context): Option[(Id, Id)] = Some((x.from, x.to))
@@ -1581,7 +1581,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
       internal.SimpleSelector_omitted(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[OmitSelector] = internal.isInstanceOfOmitSelector
+  given (using ctx: Context) as IsInstanceOf[OmitSelector] = internal.isInstanceOfOmitSelector
 
   object OmitSelector
     def unapply(x: OmitSelector)(using ctx: Context): Option[Id] = Some(x.omitted)
@@ -1688,14 +1688,14 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def isDependentFunctionType(using ctx: Context): Boolean = internal.Type_isDependentFunctionType(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Type] = internal.isInstanceOfType
+  given (using ctx: Context) as IsInstanceOf[Type] = internal.isInstanceOfType
 
   object Type {
     def apply(clazz: Class[_])(using ctx: Context): Type =
       internal.Type_apply(clazz)
   }
 
-  given (using ctx: Context): IsInstanceOf[ConstantType] = internal.isInstanceOfConstantType
+  given (using ctx: Context) as IsInstanceOf[ConstantType] = internal.isInstanceOfConstantType
 
   object ConstantType {
     def apply(x : Constant)(using ctx: Context): ConstantType = internal.ConstantType_apply(x)
@@ -1706,7 +1706,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def constant(using ctx: Context): Constant = internal.ConstantType_constant(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TermRef] = internal.isInstanceOfTermRef
+  given (using ctx: Context) as IsInstanceOf[TermRef] = internal.isInstanceOfTermRef
 
   object TermRef {
     def apply(qual: TypeOrBounds, name: String)(using ctx: Context): TermRef =
@@ -1720,7 +1720,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def name(using ctx: Context): String = internal.TermRef_name(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeRef] = internal.isInstanceOfTypeRef
+  given (using ctx: Context) as IsInstanceOf[TypeRef] = internal.isInstanceOfTypeRef
 
   object TypeRef {
     def unapply(x: TypeRef)(using ctx: Context): Option[(TypeOrBounds /* Type | NoPrefix */, String)] =
@@ -1734,7 +1734,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def translucentSuperType(using ctx: Context): Type = internal.TypeRef_translucentSuperType(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[SuperType] = internal.isInstanceOfSuperType
+  given (using ctx: Context) as IsInstanceOf[SuperType] = internal.isInstanceOfSuperType
 
   object SuperType {
     def apply(thistpe: Type, supertpe: Type)(using ctx: Context): SuperType =
@@ -1749,7 +1749,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def supertpe(using ctx: Context): Type = internal.SuperType_supertpe(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[Refinement] = internal.isInstanceOfRefinement
+  given (using ctx: Context) as IsInstanceOf[Refinement] = internal.isInstanceOfRefinement
 
   object Refinement {
     def apply(parent: Type, name: String, info: TypeOrBounds /* Type | TypeBounds */)(using ctx: Context): Refinement =
@@ -1765,7 +1765,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def info(using ctx: Context): TypeOrBounds = internal.Refinement_info(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[AppliedType] = internal.isInstanceOfAppliedType
+  given (using ctx: Context) as IsInstanceOf[AppliedType] = internal.isInstanceOfAppliedType
 
   object AppliedType {
     def apply(tycon: Type, args: List[TypeOrBounds])(using ctx: Context): AppliedType =
@@ -1779,7 +1779,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def args(using ctx: Context): List[TypeOrBounds /* Type | TypeBounds */] = internal.AppliedType_args(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[AnnotatedType] = internal.isInstanceOfAnnotatedType
+  given (using ctx: Context) as IsInstanceOf[AnnotatedType] = internal.isInstanceOfAnnotatedType
 
   object AnnotatedType {
     def apply(underlying: Type, annot: Term)(using ctx: Context): AnnotatedType =
@@ -1793,7 +1793,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def annot(using ctx: Context): Term = internal.AnnotatedType_annot(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[AndType] = internal.isInstanceOfAndType
+  given (using ctx: Context) as IsInstanceOf[AndType] = internal.isInstanceOfAndType
 
   object AndType {
     def apply(lhs: Type, rhs: Type)(using ctx: Context): AndType =
@@ -1807,7 +1807,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def right(using ctx: Context): Type = internal.AndType_right(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[OrType] = internal.isInstanceOfOrType
+  given (using ctx: Context) as IsInstanceOf[OrType] = internal.isInstanceOfOrType
 
   object OrType {
     def apply(lhs: Type, rhs: Type)(using ctx: Context): OrType = internal.OrType_apply(lhs, rhs)
@@ -1820,7 +1820,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def right(using ctx: Context): Type = internal.OrType_right(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[MatchType] = internal.isInstanceOfMatchType
+  given (using ctx: Context) as IsInstanceOf[MatchType] = internal.isInstanceOfMatchType
 
   object MatchType {
     def apply(bound: Type, scrutinee: Type, cases: List[Type])(using ctx: Context): MatchType =
@@ -1843,7 +1843,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     Type(classOf[MatchCase[_,_]])
   }
 
-  given (using ctx: Context): IsInstanceOf[ByNameType] = internal.isInstanceOfByNameType
+  given (using ctx: Context) as IsInstanceOf[ByNameType] = internal.isInstanceOfByNameType
 
   object ByNameType {
     def apply(underlying: Type)(using ctx: Context): Type = internal.ByNameType_apply(underlying)
@@ -1854,7 +1854,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def underlying(using ctx: Context): Type = internal.ByNameType_underlying(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[ParamRef] = internal.isInstanceOfParamRef
+  given (using ctx: Context) as IsInstanceOf[ParamRef] = internal.isInstanceOfParamRef
 
   object ParamRef {
     def unapply(x: ParamRef)(using ctx: Context): Option[(LambdaType[TypeOrBounds], Int)] =
@@ -1866,7 +1866,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def paramNum(using ctx: Context): Int = internal.ParamRef_paramNum(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[ThisType] = internal.isInstanceOfThisType
+  given (using ctx: Context) as IsInstanceOf[ThisType] = internal.isInstanceOfThisType
 
   object ThisType {
     def unapply(x: ThisType)(using ctx: Context): Option[Type] = Some(x.tref)
@@ -1876,7 +1876,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def tref(using ctx: Context): Type = internal.ThisType_tref(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[RecursiveThis] = internal.isInstanceOfRecursiveThis
+  given (using ctx: Context) as IsInstanceOf[RecursiveThis] = internal.isInstanceOfRecursiveThis
 
   object RecursiveThis {
     def unapply(x: RecursiveThis)(using ctx: Context): Option[RecursiveType] = Some(x.binder)
@@ -1886,7 +1886,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def binder(using ctx: Context): RecursiveType = internal.RecursiveThis_binder(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[RecursiveType] = internal.isInstanceOfRecursiveType
+  given (using ctx: Context) as IsInstanceOf[RecursiveType] = internal.isInstanceOfRecursiveType
 
   object RecursiveType {
 
@@ -1910,7 +1910,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def recThis(using ctx: Context): RecursiveThis = internal.RecursiveThis_recThis(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[MethodType] = internal.isInstanceOfMethodType
+  given (using ctx: Context) as IsInstanceOf[MethodType] = internal.isInstanceOfMethodType
 
   object MethodType {
     def apply(paramNames: List[String])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type): MethodType =
@@ -1929,7 +1929,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def resType(using ctx: Context): Type = internal.MethodType_resType(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[PolyType] = internal.isInstanceOfPolyType
+  given (using ctx: Context) as IsInstanceOf[PolyType] = internal.isInstanceOfPolyType
 
   object PolyType {
     def apply(paramNames: List[String])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => Type)(using ctx: Context): PolyType =
@@ -1945,7 +1945,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     def resType(using ctx: Context): Type = internal.PolyType_resType(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[TypeLambda] = internal.isInstanceOfTypeLambda
+  given (using ctx: Context) as IsInstanceOf[TypeLambda] = internal.isInstanceOfTypeLambda
 
   object TypeLambda {
     def apply(paramNames: List[String], boundsFn: TypeLambda => List[TypeBounds], bodyFn: TypeLambda => Type): TypeLambda =
@@ -1963,7 +1963,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // ----- TypeBounds -----------------------------------------------
 
-  given (using ctx: Context): IsInstanceOf[TypeBounds] = internal.isInstanceOfTypeBounds
+  given (using ctx: Context) as IsInstanceOf[TypeBounds] = internal.isInstanceOfTypeBounds
 
   object TypeBounds {
     def apply(low: Type, hi: Type)(using ctx: Context): TypeBounds =
@@ -1978,7 +1978,7 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
 
   // ----- NoPrefix -------------------------------------------------
 
-  given (using ctx: Context): IsInstanceOf[NoPrefix] = internal.isInstanceOfNoPrefix
+  given (using ctx: Context) as IsInstanceOf[NoPrefix] = internal.isInstanceOfNoPrefix
 
   object NoPrefix
     def unapply(x: NoPrefix)(using ctx: Context): Boolean = true
@@ -2055,23 +2055,23 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
   def searchImplicit(tpe: Type)(using ctx: Context): ImplicitSearchResult =
     internal.searchImplicit(tpe)
 
-  given (using ctx: Context): IsInstanceOf[ImplicitSearchSuccess] = internal.isInstanceOfImplicitSearchSuccess
+  given (using ctx: Context) as IsInstanceOf[ImplicitSearchSuccess] = internal.isInstanceOfImplicitSearchSuccess
 
   extension successOps on (self: ImplicitSearchSuccess) {
     def tree(using ctx: Context): Term = internal.ImplicitSearchSuccess_tree(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[ImplicitSearchFailure] = internal.isInstanceOfImplicitSearchFailure
+  given (using ctx: Context) as IsInstanceOf[ImplicitSearchFailure] = internal.isInstanceOfImplicitSearchFailure
 
   extension failureOps on (self: ImplicitSearchFailure) {
     def explanation(using ctx: Context): String = internal.ImplicitSearchFailure_explanation(self)
   }
 
-  given (using ctx: Context): IsInstanceOf[DivergingImplicit] = internal.isInstanceOfDivergingImplicit
+  given (using ctx: Context) as IsInstanceOf[DivergingImplicit] = internal.isInstanceOfDivergingImplicit
 
-  given (using ctx: Context): IsInstanceOf[NoMatchingImplicits] = internal.isInstanceOfNoMatchingImplicits
+  given (using ctx: Context) as IsInstanceOf[NoMatchingImplicits] = internal.isInstanceOfNoMatchingImplicits
 
-  given (using ctx: Context): IsInstanceOf[AmbiguousImplicits] = internal.isInstanceOfAmbiguousImplicits
+  given (using ctx: Context) as IsInstanceOf[AmbiguousImplicits] = internal.isInstanceOfAmbiguousImplicits
 
 
   /////////////