From 2ce24c37458da6ddd337e8f50e770a260aaeff1e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 2 Dec 2020 13:46:11 +0100
Subject: [PATCH] Update given syntax in the compiler and library

---
 .../backend/jvm/DottyBackendInterface.scala   |   2 +-
 compiler/src/dotty/tools/dotc/Run.scala       |   2 +-
 compiler/src/dotty/tools/dotc/ast/Trees.scala |   2 +-
 .../src/dotty/tools/dotc/core/Comments.scala  |   2 +-
 .../src/dotty/tools/dotc/core/Contexts.scala  |   2 +-
 .../dotty/tools/dotc/core/Definitions.scala   |   2 +-
 .../dotty/tools/dotc/core/TypeComparer.scala  |   2 +-
 .../tools/dotc/printing/PlainPrinter.scala    |   4 +-
 .../dotty/tools/dotc/semanticdb/Scala3.scala  |  12 +-
 .../tools/dotc/transform/ExplicitOuter.scala  |   2 +-
 .../src/dotty/tools/dotc/typer/Deriving.scala |   4 +-
 .../src/dotty/tools/dotc/typer/Namer.scala    |   4 +-
 .../tools/dotc/typer/PrepareInlineable.scala  |   2 +-
 .../dotty/tools/repl/ReplCompilerTests.scala  |   2 +-
 .../metaprogramming/erased-terms-spec.md      |   2 +-
 .../scala/quoted/Liftable.scala               | 118 +++----
 .../scala/quoted/Unliftable.scala             |  88 ++---
 library/src/scala/CanEqual.scala              |   8 +-
 library/src/scala/IArray.scala                |   4 +-
 library/src/scala/quoted/Quotes.scala         | 332 +++++++++---------
 library/src/scala/quoted/Type.scala           |   2 +-
 .../scala/runtime/stdLibPatches/Predef.scala  |   2 +-
 library/src/scala/util/FromDigits.scala       |   4 +-
 library/src/scala/util/Not.scala              |   6 +-
 scala3doc/src/dotty/dokka/DocContext.scala    |   4 +-
 .../dotty/dokka/tasty/ScalaDocSupport.scala   |   2 +-
 .../dotty/dokka/tasty/SyntheticSupport.scala  |   8 +-
 .../src/dotty/dokka/tasty/TypesSupport.scala  |  10 +-
 .../tasty/comments/CommentExpanderTests.scala |   2 +-
 tests/neg-macros/i7919.scala                  |   2 +-
 30 files changed, 319 insertions(+), 319 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index 665cf0d8c92c..9fd91b06b69c 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -124,7 +124,7 @@ object DottyBackendInterface {
     requiredModule(className)
   }
 
-  given symExtensions as AnyRef:
+  given symExtensions: AnyRef with
     extension (sym: Symbol):
 
       def isInterface(using Context): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 6fab10c9301e..5e000754436b 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -85,7 +85,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private var myCtx = rootContext(using ictx)
 
   /** The context created for this run */
-  given runContext[Dummy_so_its_a_def] as Context = myCtx
+  given runContext[Dummy_so_its_a_def]: Context = myCtx
   assert(runContext.runId <= Periods.MaxPossibleRunId)
 
   private var myUnits: List[CompilationUnit] = _
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 186329292c10..87d3c11072bb 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -1553,7 +1553,7 @@ object Trees {
     def applyOverloaded(
         receiver: tpd.Tree, method: TermName, args: List[Tree], targs: List[Type],
         expectedType: Type)(using parentCtx: Context): tpd.Tree = {
-      given ctx as Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
+      given ctx: Context = parentCtx.retractMode(Mode.ImplicitsEnabled)
       import dotty.tools.dotc.ast.tpd.TreeOps
 
       val typer = ctx.typer
diff --git a/compiler/src/dotty/tools/dotc/core/Comments.scala b/compiler/src/dotty/tools/dotc/core/Comments.scala
index 902540d2394d..33585411fa6e 100644
--- a/compiler/src/dotty/tools/dotc/core/Comments.scala
+++ b/compiler/src/dotty/tools/dotc/core/Comments.scala
@@ -15,7 +15,7 @@ object Comments {
   val ContextDoc: Key[ContextDocstrings] = new Key[ContextDocstrings]
 
   /** Decorator for getting docbase out of context */
-  given CommentsContext as AnyRef:
+  given CommentsContext: AnyRef with
     extension (c: Context) def docCtx: Option[ContextDocstrings] = c.property(ContextDoc)
 
   /** Context for Docstrings, contains basic functionality for getting
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index dc9c9838b1c5..fa0176856885 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -649,7 +649,7 @@ object Contexts {
     def setDebug: this.type = setSetting(base.settings.Ydebug, true)
   }
 
-  given ops as AnyRef:
+  given ops: AnyRef with
     extension (c: Context):
       def addNotNullInfo(info: NotNullInfo) =
         c.withNotNullInfos(c.notNullInfos.extendWith(info))
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 303d3dd32a65..da3ceed8590a 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -38,7 +38,7 @@ class Definitions {
   import Definitions._
 
   private var initCtx: Context = _
-  private given currentContext[Dummy_so_its_a_def] as Context = initCtx
+  private given currentContext[Dummy_so_its_a_def]: Context = initCtx
 
   private def newPermanentSymbol[N <: Name](owner: Symbol, name: N, flags: FlagSet, info: Type) =
     newSymbol(owner, name, flags | Permanent, info)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9b60fb63c409..fa1eba30f743 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -34,7 +34,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   private var myContext: Context = initctx
   def comparerContext: Context = myContext
 
-  protected given [DummySoItsADef] as Context = myContext
+  protected given [DummySoItsADef]: Context = myContext
 
   protected var state: TyperState = null
   def constraint: Constraint = state.constraint
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 062ab54c3037..25917e4d7aa6 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -21,7 +21,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    *  Overridden in RefinedPrinter.
    */
   protected def curCtx: Context = _ctx.addMode(Mode.Printing)
-  protected given [DummyToEnforceDef] as Context = curCtx
+  protected given [DummyToEnforceDef]: Context = curCtx
 
   protected def printDebug = ctx.settings.YprintDebug.value
 
@@ -39,7 +39,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     limiter.register(str)
     Texts.Str(str, lineRange)
 
-  given stringToText as Conversion[String, Text] = Str(_)
+  given stringToText: Conversion[String, Text] = Str(_)
 
   /** If true, tweak output so it is the same before and after pickling */
   protected def homogenizedView: Boolean = ctx.settings.YtestPickler.value
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala
index 46584dbf0097..0782bd26a7f8 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala
@@ -68,7 +68,7 @@ object Scala3:
   end Symbols
 
 
-  given NameOps as AnyRef:
+  given NameOps: AnyRef with
     extension (name: Name):
       def isWildcard = name match
         case nme.WILDCARD | WILDCARDTypeName => true
@@ -89,7 +89,7 @@ object Scala3:
         }
   end NameOps
 
-  given SymbolOps as AnyRef:
+  given SymbolOps: AnyRef with
     extension (sym: Symbol):
 
       def ifExists(using Context): Option[Symbol] = if sym.exists then Some(sym) else None
@@ -145,7 +145,7 @@ object Scala3:
       case '/' | '.' | '#' | ']' | ')' => true
       case _                           => false
 
-  given StringOps as AnyRef:
+  given StringOps: AnyRef with
     extension (symbol: String):
       def isSymbol: Boolean = !symbol.isEmpty
       def isRootPackage: Boolean = RootPackage == symbol
@@ -169,7 +169,7 @@ object Scala3:
         isJavaIdentifierStart(symbol.head) && symbol.tail.forall(isJavaIdentifierPart)
   end StringOps
 
-  given InfoOps as AnyRef:
+  given InfoOps: AnyRef with
     extension (info: SymbolInformation):
       def isAbstract: Boolean = (info.properties & SymbolInformation.Property.ABSTRACT.value) != 0
       def isFinal: Boolean = (info.properties & SymbolInformation.Property.FINAL.value) != 0
@@ -204,13 +204,13 @@ object Scala3:
       def isInterface: Boolean = info.kind.isInterface
   end InfoOps
 
-  given RangeOps as AnyRef:
+  given RangeOps: AnyRef with
     extension (range: Range):
       def hasLength = range.endLine > range.startLine || range.endCharacter > range.startCharacter
   end RangeOps
 
   /** Sort symbol occurrences by their start position. */
-  given OccurrenceOrdering as Ordering[SymbolOccurrence] = (x, y) =>
+  given OccurrenceOrdering: Ordering[SymbolOccurrence] = (x, y) =>
     x.range -> y.range match
     case None -> _ | _ -> None => 0
     case Some(a) -> Some(b) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index f18676574be5..d64c94f6bc98 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -353,7 +353,7 @@ object ExplicitOuter {
    */
   class OuterOps(val ictx: Context) extends AnyVal {
     /** The context of all operations of this class */
-    given [Dummy] as Context = ictx
+    given [Dummy]: Context = ictx
 
     /** If `cls` has an outer parameter add one to the method type `tp`. */
     def addParam(cls: ClassSymbol, tp: Type): Type =
diff --git a/compiler/src/dotty/tools/dotc/typer/Deriving.scala b/compiler/src/dotty/tools/dotc/typer/Deriving.scala
index 66e569af5856..a964e0326978 100644
--- a/compiler/src/dotty/tools/dotc/typer/Deriving.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Deriving.scala
@@ -125,11 +125,11 @@ trait Deriving {
         //
         //     ADT: C[A, B]               (A, B have same kinds at T, U)
         //
-        //          given derived$TC      as TC[              C         ]  // a "natural" instance
+        //          given derived$TC      : TC[              C         ]  // a "natural" instance
         //
         //     ADT: C[A]                  (A has same kind as U)
         //
-        //          given derived$TC      as TC[[t, u] =>>    C[      u]]
+        //          given derived$TC      : TC[[t, u] =>>    C[      u]]
         //
         // (b) The type class and all ADT type parameters are of kind *
         //
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 9297ab24c442..2f254847e378 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -669,7 +669,7 @@ class Namer { typer: Typer =>
     protected def localContext(owner: Symbol): FreshContext = ctx.fresh.setOwner(owner).setTree(original)
 
     /** The context with which this completer was created */
-    given creationContext as Context = ictx
+    given creationContext: Context = ictx
 
     // make sure testing contexts are not captured by completers
     assert(!ictx.reporter.isInstanceOf[ExploringReporter])
@@ -835,7 +835,7 @@ class Namer { typer: Typer =>
 
     override final def typeSig(sym: Symbol): Type =
       val tparamSyms = completerTypeParams(sym)(using ictx)
-      given ctx as Context = nestedCtx
+      given ctx: Context = nestedCtx
 
       def abstracted(tp: TypeBounds): TypeBounds =
         HKTypeLambda.boundsFromParams(tparamSyms, tp)
diff --git a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
index 62a0e9ec793b..80682af5affa 100644
--- a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
@@ -236,7 +236,7 @@ object PrepareInlineable {
         if (!ctx.isAfterTyper) {
           val inlineCtx = ctx
           inlined.updateAnnotation(LazyBodyAnnotation {
-            given ctx as Context = inlineCtx
+            given ctx: Context = inlineCtx
             var inlinedBody = dropInlineIfError(inlined, treeExpr)
             if inlined.isInlineMethod then
               inlinedBody = dropInlineIfError(inlined,
diff --git a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
index cf7d50265e0c..f78c6331b0e0 100644
--- a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
+++ b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
@@ -174,7 +174,7 @@ class ReplCompilerTests extends ReplTest {
         |  extension (x: T) def > (y: T) = compare(x, y) > 0
         |}
         |
-        |given IntOrd as Ord[Int] {
+        |given IntOrd: Ord[Int] with {
         |  def compare(x: Int, y: Int) =
         |  if (x < y) -1 else if (x > y) +1 else 0
         |}
diff --git a/docs/docs/reference/metaprogramming/erased-terms-spec.md b/docs/docs/reference/metaprogramming/erased-terms-spec.md
index 639ab241b177..059044c15e05 100644
--- a/docs/docs/reference/metaprogramming/erased-terms-spec.md
+++ b/docs/docs/reference/metaprogramming/erased-terms-spec.md
@@ -32,7 +32,7 @@ title: "Erased Terms Spec"
 
 3. Functions
    * `(erased x1: T1, x2: T2, ..., xN: TN) => y : (erased T1, T2, ..., TN) => R`
-   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y as (given erased T1, T2, ..., TN) => R`
+   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y: (given erased T1, T2, ..., TN) => R`
    * `(given erased T1) => R  <:<  erased T1 => R`
    * `(given erased T1, T2) => R  <:< (erased T1, T2) => R`
    *  ...
diff --git a/library/src-bootstrapped/scala/quoted/Liftable.scala b/library/src-bootstrapped/scala/quoted/Liftable.scala
index d8beadbb33f4..531e12c40913 100644
--- a/library/src-bootstrapped/scala/quoted/Liftable.scala
+++ b/library/src-bootstrapped/scala/quoted/Liftable.scala
@@ -22,70 +22,70 @@ object Liftable {
   // IMPORTANT Keep in sync with tests/run-staging/liftables.scala
 
   /** Default liftable for Boolean */
-  given BooleanLiftable[T <: Boolean] as Liftable[T] {
+  given BooleanLiftable[T <: Boolean]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Boolean(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Byte */
-  given ByteLiftable[T <: Byte] as Liftable[T] {
+  given ByteLiftable[T <: Byte]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Byte(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Short */
-  given ShortLiftable[T <: Short] as Liftable[T] {
+  given ShortLiftable[T <: Short]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Short(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Int */
-  given IntLiftable[T <: Int] as Liftable[T] {
+  given IntLiftable[T <: Int]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Int(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Long */
-  given LongLiftable[T <: Long] as Liftable[T] {
+  given LongLiftable[T <: Long]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Long(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Float */
-  given FloatLiftable[T <: Float] as Liftable[T] {
+  given FloatLiftable[T <: Float]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Float(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Double */
-  given DoubleLiftable[T <: Double] as Liftable[T] {
+  given DoubleLiftable[T <: Double]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Double(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Char */
-  given CharLiftable[T <: Char] as Liftable[T] {
+  given CharLiftable[T <: Char]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.Char(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for String */
-  given StringLiftable[T <: String] as Liftable[T] {
+  given StringLiftable[T <: String]: Liftable[T] with {
     def toExpr(x: T) =
       import quotes.reflect._
       Literal(Constant.String(x)).asExpr.asInstanceOf[Expr[T]]
   }
 
   /** Default liftable for Class[T] */
-  given ClassLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
+  given ClassLiftable[T]: Liftable[Class[T]] with {
     def toExpr(x: Class[T]) = {
       import quotes.reflect._
       Ref(defn.Predef_classOf).appliedToType(TypeRepr.typeConstructorOf(x)).asExpr.asInstanceOf[Expr[Class[T]]]
@@ -93,111 +93,111 @@ object Liftable {
   }
 
   /** Default liftable for ClassTag[T] */
-  given ClassTagLiftable[T: Type] as Liftable[ClassTag[T]] = new Liftable[ClassTag[T]] {
+  given ClassTagLiftable[T: Type]: Liftable[ClassTag[T]] with {
     def toExpr(ct: ClassTag[T]): Quotes ?=> Expr[ClassTag[T]] =
       '{ ClassTag[T](${Expr(ct.runtimeClass.asInstanceOf[Class[T]])}) }
   }
 
   /** Default liftable for Array[T] */
-  given ArrayLiftable[T: Type: Liftable: ClassTag] as Liftable[Array[T]] = new Liftable[Array[T]] {
+  given ArrayLiftable[T: Type: Liftable: ClassTag]: Liftable[Array[T]] with {
     def toExpr(arr: Array[T]): Quotes ?=> Expr[Array[T]] =
       '{ Array[T](${Expr(arr.toSeq)}: _*)(${Expr(summon[ClassTag[T]])}) }
   }
 
   /** Default liftable for Array[Boolean] */
-  given ArrayOfBooleanLiftable as Liftable[Array[Boolean]] = new Liftable[Array[Boolean]] {
+  given ArrayOfBooleanLiftable: Liftable[Array[Boolean]] with {
     def toExpr(array: Array[Boolean]): Quotes ?=> Expr[Array[Boolean]] =
       if (array.length == 0) '{ Array.emptyBooleanArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Byte] */
-  given ArrayOfByteLiftable as Liftable[Array[Byte]] = new Liftable[Array[Byte]] {
+  given ArrayOfByteLiftable: Liftable[Array[Byte]] with {
     def toExpr(array: Array[Byte]): Quotes ?=> Expr[Array[Byte]] =
       if (array.length == 0) '{ Array.emptyByteArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Short] */
-  given ArrayOfShortLiftable as Liftable[Array[Short]] = new Liftable[Array[Short]] {
+  given ArrayOfShortLiftable: Liftable[Array[Short]] with {
     def toExpr(array: Array[Short]): Quotes ?=> Expr[Array[Short]] =
       if (array.length == 0) '{ Array.emptyShortArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Char] */
-  given ArrayOfCharLiftable as Liftable[Array[Char]] = new Liftable[Array[Char]] {
+  given ArrayOfCharLiftable: Liftable[Array[Char]] with {
     def toExpr(array: Array[Char]): Quotes ?=> Expr[Array[Char]] =
       if (array.length == 0) '{ Array.emptyCharArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Int] */
-  given ArrayOfIntLiftable as Liftable[Array[Int]] = new Liftable[Array[Int]] {
+  given ArrayOfIntLiftable: Liftable[Array[Int]] with {
     def toExpr(array: Array[Int]): Quotes ?=> Expr[Array[Int]] =
       if (array.length == 0) '{ Array.emptyIntArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Long] */
-  given ArrayOfLongLiftable as Liftable[Array[Long]] = new Liftable[Array[Long]] {
+  given ArrayOfLongLiftable: Liftable[Array[Long]] with {
     def toExpr(array: Array[Long]): Quotes ?=> Expr[Array[Long]] =
       if (array.length == 0) '{ Array.emptyLongArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Float] */
-  given ArrayOfFloatLiftable as Liftable[Array[Float]] = new Liftable[Array[Float]] {
+  given ArrayOfFloatLiftable: Liftable[Array[Float]] with {
     def toExpr(array: Array[Float]): Quotes ?=> Expr[Array[Float]] =
       if (array.length == 0) '{ Array.emptyFloatArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for Array[Double] */
-  given ArrayOfDoubleLiftable as Liftable[Array[Double]] = new Liftable[Array[Double]] {
+  given ArrayOfDoubleLiftable: Liftable[Array[Double]] with {
     def toExpr(array: Array[Double]): Quotes ?=> Expr[Array[Double]] =
       if (array.length == 0) '{ Array.emptyDoubleArray }
       else '{ Array(${Expr(array(0))}, ${Expr(array.toSeq.tail)}: _*) }
   }
 
   /** Default liftable for IArray[T] */
-  given IArrayLiftable[T: Type](using ltArray: Liftable[Array[T]]) as Liftable[IArray[T]] {
+  given IArrayLiftable[T: Type](using ltArray: Liftable[Array[T]]): Liftable[IArray[T]] with {
     def toExpr(iarray: IArray[T]): Quotes ?=> Expr[IArray[T]] =
       '{ ${ltArray.toExpr(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] }
   }
 
   /** Default liftable for Seq[T] */
-  given SeqLiftable[T: Type: Liftable] as Liftable[Seq[T]] = new Liftable[Seq[T]] {
+  given SeqLiftable[T: Type: Liftable]: Liftable[Seq[T]] with {
     def toExpr(xs: Seq[T]): Quotes ?=> Expr[Seq[T]] =
       Expr.ofSeq(xs.map(summon[Liftable[T]].toExpr))
   }
 
   /** Default liftable for List[T] */
-  given ListLiftable[T: Type: Liftable] as Liftable[List[T]] = new Liftable[List[T]] {
+  given ListLiftable[T: Type: Liftable]: Liftable[List[T]] with {
     def toExpr(xs: List[T]): Quotes ?=> Expr[List[T]] =
       Expr.ofList(xs.map(summon[Liftable[T]].toExpr))
   }
 
   /** Default liftable for Nil.type */
-  given NilLiftable as Liftable[Nil.type] = new Liftable[Nil.type] {
+  given NilLiftable: Liftable[Nil.type] with {
     def toExpr(xs: Nil.type): Quotes ?=> Expr[Nil.type] =
       '{ Nil }
   }
 
   /** Default liftable for Set[T] */
-  given SetLiftable[T: Type: Liftable] as Liftable[Set[T]] = new Liftable[Set[T]] {
+  given SetLiftable[T: Type: Liftable]: Liftable[Set[T]] with {
     def toExpr(set: Set[T]): Quotes ?=> Expr[Set[T]] =
       '{ Set(${Expr(set.toSeq)}: _*) }
   }
 
   /** Default liftable for Map[T, U] */
-  given MapLiftable[T: Type: Liftable, U: Type: Liftable] as Liftable[Map[T, U]] = new Liftable[Map[T, U]] {
+  given MapLiftable[T: Type: Liftable, U: Type: Liftable]: Liftable[Map[T, U]] with {
     def toExpr(map: Map[T, U]): Quotes ?=> Expr[Map[T, U]] =
     '{ Map(${Expr(map.toSeq)}: _*) }
   }
 
   /** Default liftable for Option[T] */
-  given OptionLiftable[T: Type: Liftable] as Liftable[Option[T]] = new Liftable[Option[T]] {
+  given OptionLiftable[T: Type: Liftable]: Liftable[Option[T]] with {
     def toExpr(x: Option[T]): Quotes ?=> Expr[Option[T]] = x match {
       case x: Some[T] => Expr(x)
       case None => Expr(None)
@@ -205,68 +205,68 @@ object Liftable {
   }
 
   /** Default liftable for Some[T] */
-  given SomeLiftable[T: Type: Liftable] as Liftable[Some[T]] = new Liftable[Some[T]] {
+  given SomeLiftable[T: Type: Liftable]: Liftable[Some[T]] with {
     def toExpr(x: Some[T]): Quotes ?=> Expr[Some[T]] =
       '{ Some[T](${Expr(x.get)}) }
   }
 
   /** Default liftable for None.type */
-  given NoneLiftable as Liftable[None.type] = new Liftable[None.type] {
+  given NoneLiftable: Liftable[None.type] with {
     def toExpr(x: None.type): Quotes ?=> Expr[None.type] =
       '{ None }
   }
 
   /** Default liftable for Either[L, R] */
-  given EitherLiftable[L: Type: Liftable, R: Type: Liftable] as Liftable[Either[L, R]] = new Liftable[Either[L, R]] {
+  given EitherLiftable[L: Type: Liftable, R: Type: Liftable]: Liftable[Either[L, R]] with {
     def toExpr(x: Either[L, R]): Quotes ?=> Expr[Either[L, R]] = x match
       case x: Left[L, R] => Expr(x)
       case x: Right[L, R] => Expr(x)
   }
 
   /** Default liftable for Left[L, R] */
-  given LeftLiftable[L: Type: Liftable, R: Type] as Liftable[Left[L, R]] = new Liftable[Left[L, R]] {
+  given LeftLiftable[L: Type: Liftable, R: Type]: Liftable[Left[L, R]] with {
     def toExpr(x: Left[L, R]): Quotes ?=> Expr[Left[L, R]] =
       '{ Left[L, R](${Expr(x.value)}) }
   }
 
   /** Default liftable for Right[L, R] */
-  given RightLiftable[L: Type, R: Type: Liftable] as Liftable[Right[L, R]] = new Liftable[Right[L, R]] {
+  given RightLiftable[L: Type, R: Type: Liftable]: Liftable[Right[L, R]] with {
     def toExpr(x: Right[L, R]): Quotes ?=> Expr[Right[L, R]] =
       '{ Right[L, R](${Expr(x.value)}) }
   }
 
   /** Default liftable for EmptyTuple.type */
-  given EmptyTupleLiftable as Liftable[EmptyTuple.type] = new {
+  given EmptyTupleLiftable: Liftable[EmptyTuple.type] = new {
     def toExpr(tup: EmptyTuple.type) =
       '{ EmptyTuple }
   }
 
   /** Default liftable for Tuple1[T1] */
-  given Tuple1Liftable[T1: Type: Liftable] as Liftable[Tuple1[T1]] = new {
+  given Tuple1Liftable[T1: Type: Liftable]: Liftable[Tuple1[T1]] = new {
     def toExpr(tup: Tuple1[T1]) =
       '{ Tuple1(${Expr(tup._1)}) }
   }
 
   /** Default liftable for Tuple2[T1, T2] */
-  given Tuple2Liftable[T1: Type: Liftable, T2: Type: Liftable] as Liftable[Tuple2[T1, T2]] = new {
+  given Tuple2Liftable[T1: Type: Liftable, T2: Type: Liftable]: Liftable[Tuple2[T1, T2]] = new {
     def toExpr(tup: Tuple2[T1, T2]) =
       '{ (${Expr(tup._1)}, ${Expr(tup._2)}) }
   }
 
   /** Default liftable for Tuple3[T1, T2, T3] */
-  given Tuple3Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable] as Liftable[Tuple3[T1, T2, T3]] = new {
+  given Tuple3Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable]: Liftable[Tuple3[T1, T2, T3]] = new {
     def toExpr(tup: Tuple3[T1, T2, T3]) =
       '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}) }
   }
 
   /** Default liftable for Tuple4[T1, T2, T3, T4] */
-  given Tuple4Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable] as Liftable[Tuple4[T1, T2, T3, T4]] = new {
+  given Tuple4Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable]: Liftable[Tuple4[T1, T2, T3, T4]] = new {
     def toExpr(tup: Tuple4[T1, T2, T3, T4]) =
       '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}) }
   }
 
   /** Default liftable for Tuple5[T1, T2, T3, T4, T5] */
-  given Tuple5Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable] as Liftable[Tuple5[T1, T2, T3, T4, T5]] = new {
+  given Tuple5Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable]: Liftable[Tuple5[T1, T2, T3, T4, T5]] = new {
     def toExpr(tup: Tuple5[T1, T2, T3, T4, T5]) = {
       val (x1, x2, x3, x4, x5) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}) }
@@ -274,7 +274,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple6[T1, T2, T3, T4, T5, T6] */
-  given Tuple6Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable] as Liftable[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
+  given Tuple6Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable]: Liftable[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
     def toExpr(tup: Tuple6[T1, T2, T3, T4, T5, T6]) = {
       val (x1, x2, x3, x4, x5, x6) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}) }
@@ -282,7 +282,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple7[T1, T2, T3, T4, T5, T6, T7] */
-  given Tuple7Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable] as Liftable[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
+  given Tuple7Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable]: Liftable[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
     def toExpr(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7]) = {
       val (x1, x2, x3, x4, x5, x6, x7) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}) }
@@ -290,7 +290,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] */
-  given Tuple8Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable] as Liftable[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
+  given Tuple8Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable]: Liftable[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
     def toExpr(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}) }
@@ -298,7 +298,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] */
-  given Tuple9Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable] as Liftable[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
+  given Tuple9Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable]: Liftable[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
     def toExpr(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}) }
@@ -306,7 +306,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] */
-  given Tuple10Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable] as Liftable[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
+  given Tuple10Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable]: Liftable[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
     def toExpr(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}) }
@@ -314,7 +314,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] */
-  given Tuple11Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable] as Liftable[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
+  given Tuple11Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable]: Liftable[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
     def toExpr(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}) }
@@ -322,7 +322,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] */
-  given Tuple12Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable] as Liftable[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
+  given Tuple12Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable]: Liftable[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
     def toExpr(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}) }
@@ -330,7 +330,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] */
-  given Tuple13Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable] as Liftable[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
+  given Tuple13Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable]: Liftable[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
     def toExpr(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}) }
@@ -338,7 +338,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] */
-  given Tuple14Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable] as Liftable[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
+  given Tuple14Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable]: Liftable[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
     def toExpr(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}) }
@@ -346,7 +346,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] */
-  given Tuple15Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable] as Liftable[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
+  given Tuple15Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable]: Liftable[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
     def toExpr(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}) }
@@ -354,7 +354,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] */
-  given Tuple16Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable] as Liftable[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
+  given Tuple16Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable]: Liftable[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
     def toExpr(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}) }
@@ -362,7 +362,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] */
-  given Tuple17Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable] as Liftable[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
+  given Tuple17Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable]: Liftable[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
     def toExpr(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}) }
@@ -370,7 +370,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] */
-  given Tuple18Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable] as Liftable[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
+  given Tuple18Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable]: Liftable[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
     def toExpr(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}) }
@@ -378,7 +378,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] */
-  given Tuple19Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable] as Liftable[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
+  given Tuple19Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable]: Liftable[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
     def toExpr(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}) }
@@ -386,7 +386,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] */
-  given Tuple20Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable] as Liftable[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
+  given Tuple20Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable]: Liftable[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
     def toExpr(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}) }
@@ -394,7 +394,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] */
-  given Tuple21Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable, T21: Type: Liftable] as Liftable[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
+  given Tuple21Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable, T21: Type: Liftable]: Liftable[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
     def toExpr(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}, ${Expr(x21)}) }
@@ -402,7 +402,7 @@ object Liftable {
   }
 
   /** Default liftable for Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] */
-  given Tuple22Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable, T21: Type: Liftable, T22: Type: Liftable] as Liftable[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 Tuple22Liftable[T1: Type: Liftable, T2: Type: Liftable, T3: Type: Liftable, T4: Type: Liftable, T5: Type: Liftable, T6: Type: Liftable, T7: Type: Liftable, T8: Type: Liftable, T9: Type: Liftable, T10: Type: Liftable, T11: Type: Liftable, T12: Type: Liftable, T13: Type: Liftable, T14: Type: Liftable, T15: Type: Liftable, T16: Type: Liftable, T17: Type: Liftable, T18: Type: Liftable, T19: Type: Liftable, T20: Type: Liftable, T21: Type: Liftable, T22: Type: Liftable]: Liftable[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 toExpr(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]) = {
       val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) = tup
       '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}, ${Expr(x21)}, ${Expr(x22)}) }
@@ -410,26 +410,26 @@ object Liftable {
   }
 
   /** Default liftable for H *: T */
-  given TupleConsLiftable [H: Type: Liftable, T <: Tuple: Type: Liftable] as Liftable[H *: T] = new {
+  given TupleConsLiftable [H: Type: Liftable, T <: Tuple: Type: Liftable]: Liftable[H *: T] = new {
     def toExpr(tup: H *: T): Quotes ?=> Expr[H *: T] =
       '{ ${summon[Liftable[H]].toExpr(tup.head)} *: ${summon[Liftable[T]].toExpr(tup.tail)} }
       // '{ ${Expr(tup.head)} *: ${Expr(tup.tail)} } // TODO figure out why this fails during CI documentation
   }
 
   /** Default liftable for BigInt */
-  given BigIntLiftable as Liftable[BigInt] = new Liftable[BigInt] {
+  given BigIntLiftable: Liftable[BigInt] with {
     def toExpr(x: BigInt): Quotes ?=> Expr[BigInt] =
       '{ BigInt(${Expr(x.toByteArray)}) }
   }
 
   /** Default liftable for BigDecimal using the default MathContext */
-  given BigDecimalLiftable as Liftable[BigDecimal] = new Liftable[BigDecimal] {
+  given BigDecimalLiftable: Liftable[BigDecimal] with {
     def toExpr(x: BigDecimal): Quotes ?=> Expr[BigDecimal] =
       '{ BigDecimal(${Expr(x.toString)}) }
   }
 
   /** Default liftable for StringContext */
-  given StringContextLiftable as Liftable[StringContext] = new Liftable[StringContext] {
+  given StringContextLiftable: Liftable[StringContext] with {
     def toExpr(stringContext: StringContext): Quotes ?=> Expr[StringContext] =
       val parts = Varargs(stringContext.parts.map(Expr(_)))
       '{ StringContext($parts: _*) }
diff --git a/library/src-bootstrapped/scala/quoted/Unliftable.scala b/library/src-bootstrapped/scala/quoted/Unliftable.scala
index dbff93558d91..9c4c1d9100ec 100644
--- a/library/src-bootstrapped/scala/quoted/Unliftable.scala
+++ b/library/src-bootstrapped/scala/quoted/Unliftable.scala
@@ -28,55 +28,55 @@ object Unliftable {
    *  - Unlifts `'{false}` into `Some(false)`
    *  - Otherwise unlifts to `None`
    */
-  given BooleanUnliftable[T <: Boolean] as Unliftable[T] = new PrimitiveUnliftable
+  given BooleanUnliftable[T <: Boolean]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Byte
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Byte`
    *  - Otherwise unlifts to `None`
    */
-  given ByteUnliftable[T <: Byte] as Unliftable[T] = new PrimitiveUnliftable
+  given ByteUnliftable[T <: Byte]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Short
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Short`
    *  - Otherwise unlifts to `None`
    */
-  given ShortUnliftable[T <: Short] as Unliftable[T] = new PrimitiveUnliftable
+  given ShortUnliftable[T <: Short]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Int
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Int`
    *  - Otherwise unlifts to `None`
    */
-  given IntUnliftable[T <: Int] as Unliftable[T] = new PrimitiveUnliftable
+  given IntUnliftable[T <: Int]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Long
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Long`
    *  - Otherwise unlifts to `None`
    */
-  given LongUnliftable[T <: Long] as Unliftable[T] = new PrimitiveUnliftable
+  given LongUnliftable[T <: Long]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Float
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Float`
    *  - Otherwise unlifts to `None`
    */
-  given FloatUnliftable[T <: Float] as Unliftable[T] = new PrimitiveUnliftable
+  given FloatUnliftable[T <: Float]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Double
    *  - Unlifts `'{n}` into `Some(n)` for a literal `n` of type `Double`
    *  - Otherwise unlifts to `None`
    */
-  given DoubleUnliftable[T <: Double] as Unliftable[T] = new PrimitiveUnliftable
+  given DoubleUnliftable[T <: Double]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for Char
    *  - Unlifts `'{c}` into `Some(c)` for a literal `c` of type `Char`
    *  - Otherwise unlifts to `None`
    */
-  given CharUnliftable[T <: Char] as Unliftable[T] = new PrimitiveUnliftable
+  given CharUnliftable[T <: Char]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Default unliftable for String
    *  - Unlifts `'{str}` into `Some(str)` for a literal `str` of type `String`
    *  - Otherwise unlifts to `None`
    */
-  given StringUnliftable[T <: String] as Unliftable[T] = new PrimitiveUnliftable
+  given StringUnliftable[T <: String]: Unliftable[T] = new PrimitiveUnliftable
 
   /** Lift a quoted primitive value `'{ x }` into `x` */
   private class PrimitiveUnliftable[T <: Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Unliftable[T] {
@@ -97,7 +97,7 @@ object Unliftable {
    *  - Unlifts `'{None}` into `Some(None)`
    *  - Otherwise unlifts to `None`
    */
-  given OptionUnliftable[T](using Type[T], Unliftable[T]) as Unliftable[Option[T]] = new {
+  given OptionUnliftable[T](using Type[T], Unliftable[T]): Unliftable[Option[T]] = new {
     def fromExpr(x: Expr[Option[T]]) = x match {
       case '{ Option[T](${Unlifted(y)}) } => Some(Option(y))
       case '{ None } => Some(None)
@@ -110,7 +110,7 @@ object Unliftable {
    *  - Unlifts `'{None}` into `Some(None)`
    *  - Otherwise unlifts to `None`
    */
-  given NoneUnliftable as Unliftable[None.type] = new {
+  given NoneUnliftable: Unliftable[None.type] = new {
     def fromExpr(x: Expr[None.type]) = x match {
       case '{ None } => Some(None)
       case _ => None
@@ -121,7 +121,7 @@ object Unliftable {
    *  - Unlifts `'{Some(x)}` into `Some(Some(x))` if `x` is unliftable
    *  - Otherwise unlifts to `None`
    */
-  given SomeUnliftable[T](using Type[T], Unliftable[T]) as Unliftable[Some[T]] = new {
+  given SomeUnliftable[T](using Type[T], Unliftable[T]): Unliftable[Some[T]] = new {
     def fromExpr(x: Expr[Some[T]]) = x match {
       case '{ new Some[T](${Unlifted(y)}) } => Some(Some(y))
       case '{     Some[T](${Unlifted(y)}) } => Some(Some(y))
@@ -133,7 +133,7 @@ object Unliftable {
    *  - Unlifts `'{StringContext(args: _*)}` into `Some(StringContext(args: _*))` if `args` is explicit and each one is liftable
    *  - Otherwise unlifts to `None`
    */
-  given StringContextUnliftable as Unliftable[StringContext] = new {
+  given StringContextUnliftable: Unliftable[StringContext] = new {
     def fromExpr(x: Expr[StringContext]) = x match {
       case '{ new StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
       case '{     StringContext(${Varargs(Consts(args))}: _*) } => Some(StringContext(args: _*))
@@ -145,7 +145,7 @@ object Unliftable {
    *  - Unlifts `'{EmptyTuple}` into `Some(EmptyTuple)`
    *  - Otherwise unlifts to `None`
    */
-  given EmptyTupleUnliftable as Unliftable[EmptyTuple.type] = new {
+  given EmptyTupleUnliftable: Unliftable[EmptyTuple.type] = new {
     def fromExpr(x: Expr[EmptyTuple.type]) = x match {
       case '{ EmptyTuple } => Some(EmptyTuple)
       case _ => None
@@ -156,7 +156,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple1(x1)}` into `Some(Tuple1(x1))` if `x1` is unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple1Unliftable[T1](using Type[T1], Unliftable[T1]) as Unliftable[Tuple1[T1]] = new {
+  given Tuple1Unliftable[T1](using Type[T1], Unliftable[T1]): Unliftable[Tuple1[T1]] = new {
     def fromExpr(x: Expr[Tuple1[T1]]) = x match {
       case '{ new Tuple1[T1](${Unlifted(y)}) } => Some(Tuple1(y))
       case '{     Tuple1[T1](${Unlifted(y)}) } => Some(Tuple1(y))
@@ -168,7 +168,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple2(x1, x2)}` into `Some(Tuple2(x1, x2))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple2Unliftable[T1, T2](using Type[T1], Type[T2], Unliftable[T1], Unliftable[T2]) as Unliftable[Tuple2[T1, T2]] = new {
+  given Tuple2Unliftable[T1, T2](using Type[T1], Type[T2], Unliftable[T1], Unliftable[T2]): Unliftable[Tuple2[T1, T2]] = new {
     def fromExpr(x: Expr[Tuple2[T1, T2]]) = x match {
       case '{ new Tuple2[T1, T2](${Unlifted(y1)}, ${Unlifted(y2)}) } => Some(Tuple2(y1, y2))
       case '{     Tuple2[T1, T2](${Unlifted(y1)}, ${Unlifted(y2)}) } => Some(Tuple2(y1, y2))
@@ -181,7 +181,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple3(x1, x2, x3)}` into `Some(Tuple3(x1, x2, x3))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple3Unliftable[T1, T2, T3](using Type[T1], Type[T2], Type[T3], Unliftable[T1], Unliftable[T2], Unliftable[T3]) as Unliftable[Tuple3[T1, T2, T3]] = new {
+  given Tuple3Unliftable[T1, T2, T3](using Type[T1], Type[T2], Type[T3], Unliftable[T1], Unliftable[T2], Unliftable[T3]): Unliftable[Tuple3[T1, T2, T3]] = new {
     def fromExpr(x: Expr[Tuple3[T1, T2, T3]]) = x match {
       case '{ new Tuple3[T1, T2, T3](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}) } => Some(Tuple3(y1, y2, y3))
       case '{     Tuple3[T1, T2, T3](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}) } => Some(Tuple3(y1, y2, y3))
@@ -193,7 +193,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple4(x1, ..., x4)}` into `Some(Tuple4(x1, ..., x4))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple4Unliftable[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4]) as Unliftable[Tuple4[T1, T2, T3, T4]] = new {
+  given Tuple4Unliftable[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4]): Unliftable[Tuple4[T1, T2, T3, T4]] = new {
     def fromExpr(x: Expr[Tuple4[T1, T2, T3, T4]]) = x match {
       case '{ new Tuple4[T1, T2, T3, T4](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}) } => Some(Tuple4(y1, y2, y3, y4))
       case '{     Tuple4[T1, T2, T3, T4](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}) } => Some(Tuple4(y1, y2, y3, y4))
@@ -205,7 +205,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple5(x1, ..., x5)}` into `Some(Tuple5(x1, ..., x5))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple5Unliftable[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5]) as Unliftable[Tuple5[T1, T2, T3, T4, T5]] = new {
+  given Tuple5Unliftable[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5]): Unliftable[Tuple5[T1, T2, T3, T4, T5]] = new {
     def fromExpr(x: Expr[Tuple5[T1, T2, T3, T4, T5]]) = x match {
       case '{ new Tuple5[T1, T2, T3, T4, T5](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5))
       case '{     Tuple5[T1, T2, T3, T4, T5](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5))
@@ -217,7 +217,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple6(x1, ..., x6)}` into `Some(Tuple6(x1, ..., x6))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple6Unliftable[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6]) as Unliftable[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
+  given Tuple6Unliftable[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6]): Unliftable[Tuple6[T1, T2, T3, T4, T5, T6]] = new {
     def fromExpr(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]]) = x match {
       case '{ new Tuple6[T1, T2, T3, T4, T5, T6](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6))
       case '{     Tuple6[T1, T2, T3, T4, T5, T6](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6))
@@ -229,7 +229,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple7(x1, ..., x7)}` into `Some(Tuple7(x1, ..., x7))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple7Unliftable[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7]) as Unliftable[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
+  given Tuple7Unliftable[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7]): Unliftable[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new {
     def fromExpr(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]) = x match {
       case '{ new Tuple7[T1, T2, T3, T4, T5, T6, T7](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7))
       case '{     Tuple7[T1, T2, T3, T4, T5, T6, T7](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7))
@@ -241,7 +241,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple8(x1, ..., x8)}` into `Some(Tuple8(x1, ..., x8))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple8Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8]) as Unliftable[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
+  given Tuple8Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8]): Unliftable[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new {
     def fromExpr(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]) = x match {
       case '{ new Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8))
       case '{     Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8))
@@ -253,7 +253,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple9(x1, ..., x9)}` into `Some(Tuple9(x1, ..., x9))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple9Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9]) as Unliftable[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
+  given Tuple9Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9]): Unliftable[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new {
     def fromExpr(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]) = x match {
       case '{ new Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9))
       case '{     Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9))
@@ -265,7 +265,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple0(x1, ..., x10)}` into `Some(Tuple0(x1, ..., x10))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple10Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10]) as Unliftable[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
+  given Tuple10Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10]): Unliftable[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10))
@@ -277,7 +277,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple1(x1, ..., x11)}` into `Some(Tuple1(x1, ..., x11))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple11Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11]) as Unliftable[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
+  given Tuple11Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11]): Unliftable[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11))
@@ -289,7 +289,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple2(x1, ..., x12)}` into `Some(Tuple2(x1, ..., x12))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple12Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12]) as Unliftable[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
+  given Tuple12Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12]): Unliftable[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12))
@@ -301,7 +301,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple3(x1, ..., x13)}` into `Some(Tuple3(x1, ..., x13))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple13Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13]) as Unliftable[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
+  given Tuple13Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13]): Unliftable[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13))
@@ -313,7 +313,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple4(x1, ..., x14)}` into `Some(Tuple4(x1, ..., x14))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple14Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14]) as Unliftable[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
+  given Tuple14Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14]): Unliftable[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14))
@@ -325,7 +325,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple5(x1, ..., x15)}` into `Some(Tuple5(x1, ..., x15))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple15Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15]) as Unliftable[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
+  given Tuple15Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15]): Unliftable[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15))
@@ -337,7 +337,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple6(x1, ..., x16)}` into `Some(Tuple6(x1, ..., x16))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple16Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16]) as Unliftable[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
+  given Tuple16Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16]): Unliftable[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16))
@@ -349,7 +349,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple7(x1, ..., x17)}` into `Some(Tuple7(x1, ..., x17))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple17Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17]) as Unliftable[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
+  given Tuple17Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17]): Unliftable[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17))
@@ -361,7 +361,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple8(x1, ..., x18)}` into `Some(Tuple8(x1, ..., x18))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple18Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18]) as Unliftable[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
+  given Tuple18Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18]): Unliftable[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18))
@@ -373,7 +373,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple9(x1, ..., x19)}` into `Some(Tuple9(x1, ..., x19))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple19Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19]) as Unliftable[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
+  given Tuple19Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19]): Unliftable[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19))
@@ -385,7 +385,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple0(x1, ..., x20)}` into `Some(Tuple0(x1, ..., x20))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple20Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20]) as Unliftable[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
+  given Tuple20Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20]): Unliftable[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20))
@@ -397,7 +397,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple1(x1, ..., x21)}` into `Some(Tuple1(x1, ..., x21))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple21Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20], Unliftable[T21]) as Unliftable[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
+  given Tuple21Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20], Unliftable[T21]): Unliftable[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new {
     def fromExpr(x: Expr[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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(y20)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(y20)}, ${Unlifted(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21))
@@ -409,7 +409,7 @@ object Unliftable {
    *  - Unlifts `'{Tuple2(x1, ..., x22)}` into `Some(Tuple2(x1, ..., x22))` if all `xi` are unliftable
    *  - Otherwise unlifts to `None`
    */
-  given Tuple22Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20], Unliftable[T21], Unliftable[T22]) as Unliftable[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 Tuple22Unliftable[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], Unliftable[T1], Unliftable[T2], Unliftable[T3], Unliftable[T4], Unliftable[T5], Unliftable[T6], Unliftable[T7], Unliftable[T8], Unliftable[T9], Unliftable[T10], Unliftable[T11], Unliftable[T12], Unliftable[T13], Unliftable[T14], Unliftable[T15], Unliftable[T16], Unliftable[T17], Unliftable[T18], Unliftable[T19], Unliftable[T20], Unliftable[T21], Unliftable[T22]): Unliftable[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 fromExpr(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]]) = 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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(y20)}, ${Unlifted(y21)}, ${Unlifted(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](${Unlifted(y1)}, ${Unlifted(y2)}, ${Unlifted(y3)}, ${Unlifted(y4)}, ${Unlifted(y5)}, ${Unlifted(y6)}, ${Unlifted(y7)}, ${Unlifted(y8)}, ${Unlifted(y9)}, ${Unlifted(y10)}, ${Unlifted(y11)}, ${Unlifted(y12)}, ${Unlifted(y13)}, ${Unlifted(y14)}, ${Unlifted(y15)}, ${Unlifted(y16)}, ${Unlifted(y17)}, ${Unlifted(y18)}, ${Unlifted(y19)}, ${Unlifted(y20)}, ${Unlifted(y21)}, ${Unlifted(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))
@@ -422,7 +422,7 @@ object Unliftable {
    *  - Unlifts sequences that come out of varargs
    *  - Otherwise unlifts to `None`
    */
-  given SeqUnliftable[T](using Type[T], Unliftable[T]) as Unliftable[Seq[T]] = new {
+  given SeqUnliftable[T](using Type[T], Unliftable[T]): Unliftable[Seq[T]] = new {
     def fromExpr(x: Expr[Seq[T]]) = x match {
       case Varargs(Unlifted(elems)) => Some(elems)
       case '{ scala.Seq[T](${Varargs(Unlifted(elems))}: _*) } => Some(elems)
@@ -436,7 +436,7 @@ object Unliftable {
    *  - Unlifts `'{Nil}` into `Some(Nil)`
    *  - Otherwise unlifts to `None`
    */
-  given NilUnliftable as Unliftable[Nil.type] = new {
+  given NilUnliftable: Unliftable[Nil.type] = new {
     def fromExpr(x: Expr[Nil.type]) = x match {
       case '{ scala.Nil } |  '{ scala.collection.immutable.Nil } => Some(Nil)
       case _ => None
@@ -449,7 +449,7 @@ object Unliftable {
    *  - Unlifts `'{Nil}` into `Some(Nil)`
    *  - Otherwise unlifts to `None`
    */
-  given ListUnliftable[T](using Type[T], Unliftable[T]) as Unliftable[List[T]] = new {
+  given ListUnliftable[T](using Type[T], Unliftable[T]): Unliftable[List[T]] = new {
     def fromExpr(x: Expr[List[T]]) = x match {
       case '{ scala.List[T](${Varargs(Unlifted(elems))}: _*) } => Some(elems.toList)
       case '{ scala.List.empty[T] } => Some(Nil)
@@ -465,7 +465,7 @@ object Unliftable {
    *  - Unlifts `'{Set.empty}` into `Some(Set())`
    *  - Otherwise unlifts to `None`
    */
-  given SetUnliftable[T](using Type[T], Unliftable[T]) as Unliftable[Set[T]] = new {
+  given SetUnliftable[T](using Type[T], Unliftable[T]): Unliftable[Set[T]] = new {
     def fromExpr(x: Expr[Set[T]]) = x match {
       case '{ Set[T](${Varargs(Unlifted(elems))}: _*) } => Some(elems.toSet)
       case '{ Set.empty[T] } => Some(Set.empty[T])
@@ -480,7 +480,7 @@ object Unliftable {
    *  - Unlifts `'{Map.empty}` into `Some(Map())`
    *  - Otherwise unlifts to `None`
    */
-  given MapUnliftable[T, U](using Type[T], Type[U], Unliftable[T], Unliftable[U]) as Unliftable[Map[T, U]] = new {
+  given MapUnliftable[T, U](using Type[T], Type[U], Unliftable[T], Unliftable[U]): Unliftable[Map[T, U]] = new {
     def fromExpr(x: Expr[Map[T, U]]) = x match {
       case '{ Map[T, U](${Varargs(Unlifted(elems))}: _*) } => Some(elems.toMap)
       case '{ Map.empty[T, U] } => Some(Map.empty)
@@ -495,7 +495,7 @@ object Unliftable {
    *  - Unlifts `'{Right(x)}` into `Some(Right(x))` if `x` is unliftable
    *  - Otherwise unlifts to `None`
    */
-  given EitherUnliftable[L, R](using Type[L], Type[R], Unliftable[L], Unliftable[R]) as Unliftable[Either[L, R]] = new {
+  given EitherUnliftable[L, R](using Type[L], Type[R], Unliftable[L], Unliftable[R]): Unliftable[Either[L, R]] = new {
     def fromExpr(x: Expr[Either[L, R]]) = x match {
       case '{ $x: Left[L, R] } => x.unlift
       case '{ $x: Right[L, R] } => x.unlift
@@ -507,7 +507,7 @@ object Unliftable {
    *  - Unlifts `'{Left(x)}` into `Some(Left(x))` if `x` is unliftable
    *  - Otherwise unlifts to `None`
    */
-  given LeftUnliftable[L, R](using Type[L], Type[R], Unliftable[L]) as Unliftable[Left[L, R]] = new {
+  given LeftUnliftable[L, R](using Type[L], Type[R], Unliftable[L]): Unliftable[Left[L, R]] = new {
     def fromExpr(x: Expr[Left[L, R]]) = x match {
       case '{ Left[L, R](${Unlifted(x)}) } => Some(Left(x))
       case _ => None
@@ -518,7 +518,7 @@ object Unliftable {
    *  - Unlifts `'{Right(x)}` into `Some(Right(x))` if `x` is unliftable
    *  - Otherwise unlifts to `None`
    */
-  given RightUnliftable[L, R](using Type[L], Type[R], Unliftable[R]) as Unliftable[Right[L, R]] = new {
+  given RightUnliftable[L, R](using Type[L], Type[R], Unliftable[R]): Unliftable[Right[L, R]] = new {
     def fromExpr(x: Expr[Right[L, R]]) = x match {
       case '{ Right[L, R](${Unlifted(x)}) } => Some(Right(x))
       case _ => None
diff --git a/library/src/scala/CanEqual.scala b/library/src/scala/CanEqual.scala
index 8815c086d36c..39e5389df989 100644
--- a/library/src/scala/CanEqual.scala
+++ b/library/src/scala/CanEqual.scala
@@ -23,12 +23,12 @@ object CanEqual {
   def canEqualAny[L, R]: CanEqual[L, R] = derived
 
   // Instances of `CanEqual` for common Java types
-  given canEqualNumber as CanEqual[Number, Number] = derived
-  given canEqualString as CanEqual[String, String] = derived
+  given canEqualNumber: CanEqual[Number, Number] = derived
+  given canEqualString: CanEqual[String, String] = derived
 
   // The next three definitions can go into the companion objects of classes
   // Seq and Set. For now they are here in order not to have to touch the
   // source code of these classes
-  given canEqualSeq[T, U](using eq: CanEqual[T, U]) as CanEqual[Seq[T], Seq[U]] = derived
-  given canEqualSet[T, U](using eq: CanEqual[T, U]) as CanEqual[Set[T], Set[U]] = derived
+  given canEqualSeq[T, U](using eq: CanEqual[T, U]): CanEqual[Seq[T], Seq[U]] = derived
+  given canEqualSet[T, U](using eq: CanEqual[T, U]): CanEqual[Set[T], Set[U]] = derived
 }
diff --git a/library/src/scala/IArray.scala b/library/src/scala/IArray.scala
index 5fcb16e43d56..f66bad0b6b20 100644
--- a/library/src/scala/IArray.scala
+++ b/library/src/scala/IArray.scala
@@ -11,7 +11,7 @@ object opaques:
   private[scala] type Sup[A] >: IArray[A] <: Array[_ <: A]
 
   /** Defines extension methods for immutable arrays */
-  given arrayOps as Object {
+  given arrayOps: Object with {
 
     /** The selection operation on an immutable array.
       *
@@ -266,7 +266,7 @@ object IArray {
   import opaques.Sup
 
   // A convenience to avoid having to cast everything by hand
-  private given [A] as Conversion[Array[A], IArray[A]] = identity[Sub[A]]
+  private given [A]: Conversion[Array[A], IArray[A]] = identity[Sub[A]]
 
   /** Convert an array into an immutable array without copying, the original array
    *   must _not_ be mutated after this or the guaranteed immutablity of IArray will
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 3c311ba7821f..147e9e3b3f02 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -199,7 +199,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Tree` available without any imports */
-    given TreeMethods as TreeMethods = TreeMethodsImpl
+    given TreeMethods: TreeMethods = TreeMethodsImpl
 
     /** Implementation of extension methods on `Tree` */
     protected val TreeMethodsImpl: TreeMethods
@@ -248,7 +248,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type PackageClause <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `PackageClause` */
-    given PackageClauseTypeTest as TypeTest[Tree, PackageClause] = PackageClauseTypeTestImpl
+    given PackageClauseTypeTest: TypeTest[Tree, PackageClause] = PackageClauseTypeTestImpl
 
     /** Implementation of `PackageClauseTypeTest` */
     protected val PackageClauseTypeTestImpl: TypeTest[Tree, PackageClause]
@@ -264,7 +264,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `PackageClause` available without any imports */
-    given PackageClauseMethods as PackageClauseMethods = PackageClauseMethodsImpl
+    given PackageClauseMethods: PackageClauseMethods = PackageClauseMethodsImpl
 
     /** Implementation of extension methods on `PackageClause` */
     protected val PackageClauseMethodsImpl: PackageClauseMethods
@@ -281,7 +281,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Import <: Statement
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Import` */
-    given ImportTypeTest as TypeTest[Tree, Import] = ImportTypeTestImpl
+    given ImportTypeTest: TypeTest[Tree, Import] = ImportTypeTestImpl
 
     /** Implementation of `ImportTypeTest` */
     protected val ImportTypeTestImpl: TypeTest[Tree, Import]
@@ -297,7 +297,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Import` available without any imports */
-    given ImportMethods as ImportMethods = ImportMethodsImpl
+    given ImportMethods: ImportMethods = ImportMethodsImpl
 
     /** Implementation of extension methods on `Import` */
     protected val ImportMethodsImpl: ImportMethods
@@ -314,7 +314,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Statement <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Statement` */
-    given StatementTypeTest as TypeTest[Tree, Statement] = StatementTypeTestImpl
+    given StatementTypeTest: TypeTest[Tree, Statement] = StatementTypeTestImpl
 
     /** Implementation of `StatementTypeTest` */
     protected val StatementTypeTestImpl: TypeTest[Tree, Statement]
@@ -325,7 +325,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Definition <: Statement
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Definition` */
-    given DefinitionTypeTest as TypeTest[Tree, Definition] = DefinitionTypeTestImpl
+    given DefinitionTypeTest: TypeTest[Tree, Definition] = DefinitionTypeTestImpl
 
     /** Implementation of `DefinitionTypeTest` */
     protected val DefinitionTypeTestImpl: TypeTest[Tree, Definition]
@@ -337,7 +337,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     trait DefinitionModule { this: Definition.type => }
 
     /** Makes extension methods on `Definition` available without any imports */
-    given DefinitionMethods as DefinitionMethods = DefinitionMethodsImpl
+    given DefinitionMethods: DefinitionMethods = DefinitionMethodsImpl
 
     /** Implementation of extension methods on `Definition` */
     protected val DefinitionMethodsImpl: DefinitionMethods
@@ -355,7 +355,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ClassDef <: Definition
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `ClassDef` */
-    given ClassDefTypeTest as TypeTest[Tree, ClassDef] = ClassDefTypeTestImpl
+    given ClassDefTypeTest: TypeTest[Tree, ClassDef] = ClassDefTypeTestImpl
 
     /** Implementation of `ClassDefTypeTest` */
     protected val ClassDefTypeTestImpl: TypeTest[Tree, ClassDef]
@@ -371,7 +371,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ClassDef` available without any imports */
-    given ClassDefMethods as ClassDefMethods = ClassDefMethodsImpl
+    given ClassDefMethods: ClassDefMethods = ClassDefMethodsImpl
 
     /** Implementation of extension methods on `ClassDef` */
     protected val ClassDefMethodsImpl: ClassDefMethods
@@ -393,7 +393,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type DefDef <: Definition
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `DefDef` */
-    given DefDefTypeTest as TypeTest[Tree, DefDef] = DefDefTypeTestImpl
+    given DefDefTypeTest: TypeTest[Tree, DefDef] = DefDefTypeTestImpl
 
     /** Implementation of `DefDefTypeTest` */
     protected val DefDefTypeTestImpl: TypeTest[Tree, DefDef]
@@ -409,7 +409,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `DefDef` available without any imports */
-    given DefDefMethods as DefDefMethods = DefDefMethodsImpl
+    given DefDefMethods: DefDefMethods = DefDefMethodsImpl
 
     /** Implementation of extension methods on `DefDef` */
     protected val DefDefMethodsImpl: DefDefMethods
@@ -430,7 +430,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ValDef <: Definition
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `ValDef` */
-    given ValDefTypeTest as TypeTest[Tree, ValDef] = ValDefTypeTestImpl
+    given ValDefTypeTest: TypeTest[Tree, ValDef] = ValDefTypeTestImpl
 
     /** Implementation of `ValDefTypeTest` */
     protected val ValDefTypeTestImpl: TypeTest[Tree, ValDef]
@@ -456,7 +456,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ValDef` available without any imports */
-    given ValDefMethods as ValDefMethods = ValDefMethodsImpl
+    given ValDefMethods: ValDefMethods = ValDefMethodsImpl
 
     /** Implementation of extension methods on `ValDef` */
     protected val ValDefMethodsImpl: ValDefMethods
@@ -475,7 +475,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeDef <: Definition
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeDef` */
-    given TypeDefTypeTest as TypeTest[Tree, TypeDef] = TypeDefTypeTestImpl
+    given TypeDefTypeTest: TypeTest[Tree, TypeDef] = TypeDefTypeTestImpl
 
     /** Implementation of `TypeDefTypeTest` */
     protected val TypeDefTypeTestImpl: TypeTest[Tree, TypeDef]
@@ -491,7 +491,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeDef` available without any imports */
-    given TypeDefMethods as TypeDefMethods = TypeDefMethodsImpl
+    given TypeDefMethods: TypeDefMethods = TypeDefMethodsImpl
 
     /** Implementation of extension methods on `TypeDef` */
     protected val TypeDefMethodsImpl: TypeDefMethods
@@ -510,7 +510,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Term <: Statement
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Term` */
-    given TermTypeTest as TypeTest[Tree, Term] = TermTypeTestImpl
+    given TermTypeTest: TypeTest[Tree, Term] = TermTypeTestImpl
 
     /** Implementation of `TermTypeTest` */
     protected val TermTypeTestImpl: TypeTest[Tree, Term]
@@ -538,7 +538,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Term` available without any imports */
-    given TermMethods as TermMethods = TermMethodsImpl
+    given TermMethods: TermMethods = TermMethodsImpl
 
     /** Implementation of extension methods on `Term` */
     protected val TermMethodsImpl: TermMethods
@@ -596,7 +596,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Ref <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Ref` */
-    given RefTypeTest as TypeTest[Tree, Ref] = RefTypeTestImpl
+    given RefTypeTest: TypeTest[Tree, Ref] = RefTypeTestImpl
 
     /** Implementation of `RefTypeTest` */
     protected val RefTypeTestImpl: TypeTest[Tree, Ref]
@@ -631,7 +631,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Ident <: Ref
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Ident` */
-    given IdentTypeTest as TypeTest[Tree, Ident] = IdentTypeTestImpl
+    given IdentTypeTest: TypeTest[Tree, Ident] = IdentTypeTestImpl
 
     /** Implementation of `IdentTypeTest` */
     protected val IdentTypeTestImpl: TypeTest[Tree, Ident]
@@ -650,7 +650,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Ident` available without any imports */
-    given IdentMethods as IdentMethods = IdentMethodsImpl
+    given IdentMethods: IdentMethods = IdentMethodsImpl
 
     /** Implementation of extension methods on `Ident` */
     protected val IdentMethodsImpl: IdentMethods
@@ -666,7 +666,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Select <: Ref
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Select` */
-    given SelectTypeTest as TypeTest[Tree, Select] = SelectTypeTestImpl
+    given SelectTypeTest: TypeTest[Tree, Select] = SelectTypeTestImpl
 
     /** Implementation of `SelectTypeTest` */
     protected val SelectTypeTestImpl: TypeTest[Tree, Select]
@@ -700,7 +700,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Select` available without any imports */
-    given SelectMethods as SelectMethods = SelectMethodsImpl
+    given SelectMethods: SelectMethods = SelectMethodsImpl
 
     /** Implementation of extension methods on `Select` */
     protected val SelectMethodsImpl: SelectMethods
@@ -715,7 +715,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end SelectMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Literal` */
-    given LiteralTypeTest as TypeTest[Tree, Literal] = LiteralTypeTestImpl
+    given LiteralTypeTest: TypeTest[Tree, Literal] = LiteralTypeTestImpl
 
     /** Implementation of `LiteralTypeTest` */
     protected val LiteralTypeTestImpl: TypeTest[Tree, Literal]
@@ -739,7 +739,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Literal` available without any imports */
-    given LiteralMethods as LiteralMethods = LiteralMethodsImpl
+    given LiteralMethods: LiteralMethods = LiteralMethodsImpl
 
     /** Implementation of extension methods on `Literal` */
     protected val LiteralMethodsImpl: LiteralMethods
@@ -755,7 +755,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type This <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `This` */
-    given ThisTypeTest as TypeTest[Tree, This] = ThisTypeTestImpl
+    given ThisTypeTest: TypeTest[Tree, This] = ThisTypeTestImpl
 
     /** Implementation of `ThisTypeTest` */
     protected val ThisTypeTestImpl: TypeTest[Tree, This]
@@ -776,7 +776,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `This` available without any imports */
-    given ThisMethods as ThisMethods = ThisMethodsImpl
+    given ThisMethods: ThisMethods = ThisMethodsImpl
 
     /** Implementation of extension methods on `This` */
     protected val ThisMethodsImpl: ThisMethods
@@ -792,7 +792,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type New <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `New` */
-    given NewTypeTest as TypeTest[Tree, New] = NewTypeTestImpl
+    given NewTypeTest: TypeTest[Tree, New] = NewTypeTestImpl
 
     /** Implementation of `NewTypeTest` */
     protected val NewTypeTestImpl: TypeTest[Tree, New]
@@ -813,7 +813,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `New` available without any imports */
-    given NewMethods as NewMethods = NewMethodsImpl
+    given NewMethods: NewMethods = NewMethodsImpl
 
     /** Implementation of extension methods on `New` */
     protected val NewMethodsImpl: NewMethods
@@ -829,7 +829,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type NamedArg <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `NamedArg` */
-    given NamedArgTypeTest as TypeTest[Tree, NamedArg] = NamedArgTypeTestImpl
+    given NamedArgTypeTest: TypeTest[Tree, NamedArg] = NamedArgTypeTestImpl
 
     /** Implementation of `NamedArgTypeTest` */
     protected val NamedArgTypeTestImpl: TypeTest[Tree, NamedArg]
@@ -850,7 +850,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `NamedArg` available without any imports */
-    given NamedArgMethods as NamedArgMethods = NamedArgMethodsImpl
+    given NamedArgMethods: NamedArgMethods = NamedArgMethodsImpl
 
     /** Implementation of extension methods on `NamedArg` */
     protected val NamedArgMethodsImpl: NamedArgMethods
@@ -867,7 +867,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Apply <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Apply` */
-    given ApplyTypeTest as TypeTest[Tree, Apply] = ApplyTypeTestImpl
+    given ApplyTypeTest: TypeTest[Tree, Apply] = ApplyTypeTestImpl
 
     /** Implementation of `ApplyTypeTest` */
     protected val ApplyTypeTestImpl: TypeTest[Tree, Apply]
@@ -888,7 +888,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Apply` available without any imports */
-    given ApplyMethods as ApplyMethods = ApplyMethodsImpl
+    given ApplyMethods: ApplyMethods = ApplyMethodsImpl
 
     /** Implementation of extension methods on `Apply` */
     protected val ApplyMethodsImpl: ApplyMethods
@@ -905,7 +905,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeApply <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeApply` */
-    given TypeApplyTypeTest as TypeTest[Tree, TypeApply] = TypeApplyTypeTestImpl
+    given TypeApplyTypeTest: TypeTest[Tree, TypeApply] = TypeApplyTypeTestImpl
 
     /** Implementation of `TypeApplyTypeTest` */
     protected val TypeApplyTypeTestImpl: TypeTest[Tree, TypeApply]
@@ -926,7 +926,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeApply` available without any imports */
-    given TypeApplyMethods as TypeApplyMethods = TypeApplyMethodsImpl
+    given TypeApplyMethods: TypeApplyMethods = TypeApplyMethodsImpl
 
     /** Implementation of extension methods on `TypeApply` */
     protected val TypeApplyMethodsImpl: TypeApplyMethods
@@ -940,7 +940,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end TypeApplyMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Super` */
-    given SuperTypeTest as TypeTest[Tree, Super] = SuperTypeTestImpl
+    given SuperTypeTest: TypeTest[Tree, Super] = SuperTypeTestImpl
 
     /** Implementation of `SuperTypeTest` */
     protected val SuperTypeTestImpl: TypeTest[Tree, Super]
@@ -964,7 +964,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Super` available without any imports */
-    given SuperMethods as SuperMethods = SuperMethodsImpl
+    given SuperMethods: SuperMethods = SuperMethodsImpl
 
     /** Implementation of extension methods on `Super` */
     protected val SuperMethodsImpl: SuperMethods
@@ -979,7 +979,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end SuperMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Typed` */
-    given TypedTypeTest as TypeTest[Tree, Typed] = TypedTypeTestImpl
+    given TypedTypeTest: TypeTest[Tree, Typed] = TypedTypeTestImpl
 
     /** Implementation of `TypedTypeTest` */
     protected val TypedTypeTestImpl: TypeTest[Tree, Typed]
@@ -1003,7 +1003,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Typed` available without any imports */
-    given TypedMethods as TypedMethods = TypedMethodsImpl
+    given TypedMethods: TypedMethods = TypedMethodsImpl
 
     /** Implementation of extension methods on `Typed` */
     protected val TypedMethodsImpl: TypedMethods
@@ -1020,7 +1020,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Assign <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Assign` */
-    given AssignTypeTest as TypeTest[Tree, Assign] = AssignTypeTestImpl
+    given AssignTypeTest: TypeTest[Tree, Assign] = AssignTypeTestImpl
 
     /** Implementation of `AssignTypeTest` */
     protected val AssignTypeTestImpl: TypeTest[Tree, Assign]
@@ -1041,7 +1041,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Assign` available without any imports */
-    given AssignMethods as AssignMethods = AssignMethodsImpl
+    given AssignMethods: AssignMethods = AssignMethodsImpl
 
     /** Implementation of extension methods on `Assign` */
     protected val AssignMethodsImpl: AssignMethods
@@ -1058,7 +1058,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Block <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Block` */
-    given BlockTypeTest as TypeTest[Tree, Block] = BlockTypeTestImpl
+    given BlockTypeTest: TypeTest[Tree, Block] = BlockTypeTestImpl
 
     /** Implementation of `BlockTypeTest` */
     protected val BlockTypeTestImpl: TypeTest[Tree, Block]
@@ -1079,7 +1079,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Block` available without any imports */
-    given BlockMethods as BlockMethods = BlockMethodsImpl
+    given BlockMethods: BlockMethods = BlockMethodsImpl
 
     /** Implementation of extension methods on `Block` */
     protected val BlockMethodsImpl: BlockMethods
@@ -1093,7 +1093,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end BlockMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Closure` */
-    given ClosureTypeTest as TypeTest[Tree, Closure] = ClosureTypeTestImpl
+    given ClosureTypeTest: TypeTest[Tree, Closure] = ClosureTypeTestImpl
 
     /** Implementation of `ClosureTypeTest` */
     protected val ClosureTypeTestImpl: TypeTest[Tree, Closure]
@@ -1123,7 +1123,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Closure` available without any imports */
-    given ClosureMethods as ClosureMethods = ClosureMethodsImpl
+    given ClosureMethods: ClosureMethods = ClosureMethodsImpl
 
     /** Implementation of extension methods on `Closure` */
     protected val ClosureMethodsImpl: ClosureMethods
@@ -1173,7 +1173,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `If` */
-    given IfTypeTest as TypeTest[Tree, If] = IfTypeTestImpl
+    given IfTypeTest: TypeTest[Tree, If] = IfTypeTestImpl
 
     /** Implementation of `IfTypeTest` */
     protected val IfTypeTestImpl: TypeTest[Tree, If]
@@ -1197,7 +1197,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `If` available without any imports */
-    given IfMethods as IfMethods = IfMethodsImpl
+    given IfMethods: IfMethods = IfMethodsImpl
 
     /** Implementation of extension methods on `If` */
     protected val IfMethodsImpl: IfMethods
@@ -1215,7 +1215,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Match <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Match` */
-    given MatchTypeTest as TypeTest[Tree, Match] = MatchTypeTestImpl
+    given MatchTypeTest: TypeTest[Tree, Match] = MatchTypeTestImpl
 
     /** Implementation of `MatchTypeTest` */
     protected val MatchTypeTestImpl: TypeTest[Tree, Match]
@@ -1236,7 +1236,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Match` available without any imports */
-    given MatchMethods as MatchMethods = MatchMethodsImpl
+    given MatchMethods: MatchMethods = MatchMethodsImpl
 
     /** Implementation of extension methods on `Match` */
     protected val MatchMethodsImpl: MatchMethods
@@ -1253,7 +1253,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type SummonFrom <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `SummonFrom` */
-    given SummonFromTypeTest as TypeTest[Tree, SummonFrom] = SummonFromTypeTestImpl
+    given SummonFromTypeTest: TypeTest[Tree, SummonFrom] = SummonFromTypeTestImpl
 
     /** Implementation of `SummonFromTypeTest` */
     protected val SummonFromTypeTestImpl: TypeTest[Tree, SummonFrom]
@@ -1274,7 +1274,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `SummonFrom` available without any imports */
-    given SummonFromMethods as SummonFromMethods = SummonFromMethodsImpl
+    given SummonFromMethods: SummonFromMethods = SummonFromMethodsImpl
 
     /** Implementation of extension methods on `SummonFrom` */
     protected val SummonFromMethodsImpl: SummonFromMethods
@@ -1290,7 +1290,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Try <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Try` */
-    given TryTypeTest as TypeTest[Tree, Try] = TryTypeTestImpl
+    given TryTypeTest: TypeTest[Tree, Try] = TryTypeTestImpl
 
     /** Implementation of `TryTypeTest` */
     protected val TryTypeTestImpl: TypeTest[Tree, Try]
@@ -1311,7 +1311,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Try` available without any imports */
-    given TryMethods as TryMethods = TryMethodsImpl
+    given TryMethods: TryMethods = TryMethodsImpl
 
     /** Implementation of extension methods on `Try` */
     protected val TryMethodsImpl: TryMethods
@@ -1326,7 +1326,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     end TryMethods
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Return` */
-    given ReturnTypeTest as TypeTest[Tree, Return] = ReturnTypeTestImpl
+    given ReturnTypeTest: TypeTest[Tree, Return] = ReturnTypeTestImpl
 
     /** Implementation of `ReturnTypeTest` */
     protected val ReturnTypeTestImpl: TypeTest[Tree, Return]
@@ -1350,7 +1350,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Return` available without any imports */
-    given ReturnMethods as ReturnMethods = ReturnMethodsImpl
+    given ReturnMethods: ReturnMethods = ReturnMethodsImpl
 
     /** Implementation of extension methods on `Return` */
     protected val ReturnMethodsImpl: ReturnMethods
@@ -1367,7 +1367,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Repeated <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Repeated` */
-    given RepeatedTypeTest as TypeTest[Tree, Repeated] = RepeatedTypeTestImpl
+    given RepeatedTypeTest: TypeTest[Tree, Repeated] = RepeatedTypeTestImpl
 
     /** Implementation of `RepeatedTypeTest` */
     protected val RepeatedTypeTestImpl: TypeTest[Tree, Repeated]
@@ -1383,7 +1383,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Repeated` available without any imports */
-    given RepeatedMethods as RepeatedMethods = RepeatedMethodsImpl
+    given RepeatedMethods: RepeatedMethods = RepeatedMethodsImpl
 
     /** Implementation of extension methods on `Repeated` */
     protected val RepeatedMethodsImpl: RepeatedMethods
@@ -1400,7 +1400,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Inlined <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Inlined` */
-    given InlinedTypeTest as TypeTest[Tree, Inlined] = InlinedTypeTestImpl
+    given InlinedTypeTest: TypeTest[Tree, Inlined] = InlinedTypeTestImpl
 
     /** Implementation of `InlinedTypeTest` */
     protected val InlinedTypeTestImpl: TypeTest[Tree, Inlined]
@@ -1416,7 +1416,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Inlined` available without any imports */
-    given InlinedMethods as InlinedMethods = InlinedMethodsImpl
+    given InlinedMethods: InlinedMethods = InlinedMethodsImpl
 
     /** Implementation of extension methods on `Inlined` */
     protected val InlinedMethodsImpl: InlinedMethods
@@ -1434,7 +1434,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type SelectOuter <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `SelectOuter` */
-    given SelectOuterTypeTest as TypeTest[Tree, SelectOuter] = SelectOuterTypeTestImpl
+    given SelectOuterTypeTest: TypeTest[Tree, SelectOuter] = SelectOuterTypeTestImpl
 
     /** Implementation of `SelectOuterTypeTest` */
     protected val SelectOuterTypeTestImpl: TypeTest[Tree, SelectOuter]
@@ -1450,7 +1450,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `SelectOuter` available without any imports */
-    given SelectOuterMethods as SelectOuterMethods = SelectOuterMethodsImpl
+    given SelectOuterMethods: SelectOuterMethods = SelectOuterMethodsImpl
 
     /** Implementation of extension methods on `SelectOuter` */
     protected val SelectOuterMethodsImpl: SelectOuterMethods
@@ -1468,7 +1468,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type While <: Term
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `While` */
-    given WhileTypeTest as TypeTest[Tree, While] = WhileTypeTestImpl
+    given WhileTypeTest: TypeTest[Tree, While] = WhileTypeTestImpl
 
     /** Implementation of `WhileTypeTest` */
     protected val WhileTypeTestImpl: TypeTest[Tree, While]
@@ -1489,7 +1489,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `While` available without any imports */
-    given WhileMethods as WhileMethods = WhileMethodsImpl
+    given WhileMethods: WhileMethods = WhileMethodsImpl
 
     /** Implementation of extension methods on `While` */
     protected val WhileMethodsImpl: WhileMethods
@@ -1508,7 +1508,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeTree <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeTree` */
-    given TypeTreeTypeTest as TypeTest[Tree, TypeTree] = TypeTreeTypeTestImpl
+    given TypeTreeTypeTest: TypeTest[Tree, TypeTree] = TypeTreeTypeTestImpl
 
     /** Implementation of `TypeTreeTypeTest` */
     protected val TypeTreeTypeTestImpl: TypeTest[Tree, TypeTree]
@@ -1523,7 +1523,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeTree` available without any imports */
-    given TypeTreeMethods as TypeTreeMethods = TypeTreeMethodsImpl
+    given TypeTreeMethods: TypeTreeMethods = TypeTreeMethodsImpl
 
     /** Implementation of extension methods on `TypeTree` */
     protected val TypeTreeMethodsImpl: TypeTreeMethods
@@ -1540,7 +1540,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Inferred <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Inferred` */
-    given InferredTypeTest as TypeTest[Tree, Inferred] = InferredTypeTestImpl
+    given InferredTypeTest: TypeTest[Tree, Inferred] = InferredTypeTestImpl
 
     /** Implementation of `InferredTypeTest` */
     protected val InferredTypeTestImpl: TypeTest[Tree, Inferred]
@@ -1559,7 +1559,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeIdent <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeIdent` */
-    given TypeIdentTypeTest as TypeTest[Tree, TypeIdent] = TypeIdentTypeTestImpl
+    given TypeIdentTypeTest: TypeTest[Tree, TypeIdent] = TypeIdentTypeTestImpl
 
     /** Implementation of `TypeIdentTypeTest` */
     protected val TypeIdentTypeTestImpl: TypeTest[Tree, TypeIdent]
@@ -1575,7 +1575,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeIdent` available without any imports */
-    given TypeIdentMethods as TypeIdentMethods = TypeIdentMethodsImpl
+    given TypeIdentMethods: TypeIdentMethods = TypeIdentMethodsImpl
 
     /** Implementation of extension methods on `TypeIdent` */
     protected val TypeIdentMethodsImpl: TypeIdentMethods
@@ -1591,7 +1591,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeSelect <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeSelect` */
-    given TypeSelectTypeTest as TypeTest[Tree, TypeSelect] = TypeSelectTypeTestImpl
+    given TypeSelectTypeTest: TypeTest[Tree, TypeSelect] = TypeSelectTypeTestImpl
 
     /** Implementation of `TypeSelectTypeTest` */
     protected val TypeSelectTypeTestImpl: TypeTest[Tree, TypeSelect]
@@ -1607,7 +1607,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeSelect` available without any imports */
-    given TypeSelectMethods as TypeSelectMethods = TypeSelectMethodsImpl
+    given TypeSelectMethods: TypeSelectMethods = TypeSelectMethodsImpl
 
     /** Implementation of extension methods on `TypeSelect` */
     protected val TypeSelectMethodsImpl: TypeSelectMethods
@@ -1624,7 +1624,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeProjection <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeProjection` */
-    given TypeProjectionTypeTest as TypeTest[Tree, TypeProjection] = TypeProjectionTypeTestImpl
+    given TypeProjectionTypeTest: TypeTest[Tree, TypeProjection] = TypeProjectionTypeTestImpl
 
     /** Implementation of `TypeProjectionTypeTest` */
     protected val TypeProjectionTypeTestImpl: TypeTest[Tree, TypeProjection]
@@ -1640,7 +1640,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeProjection` available without any imports */
-    given TypeProjectionMethods as TypeProjectionMethods = TypeProjectionMethodsImpl
+    given TypeProjectionMethods: TypeProjectionMethods = TypeProjectionMethodsImpl
 
     /** Implementation of extension methods on `TypeProjection` */
     protected val TypeProjectionMethodsImpl: TypeProjectionMethods
@@ -1657,7 +1657,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Singleton <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Singleton` */
-    given SingletonTypeTest as TypeTest[Tree, Singleton] = SingletonTypeTestImpl
+    given SingletonTypeTest: TypeTest[Tree, Singleton] = SingletonTypeTestImpl
 
     /** Implementation of `SingletonTypeTest` */
     protected val SingletonTypeTestImpl: TypeTest[Tree, Singleton]
@@ -1673,7 +1673,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Singleton` available without any imports */
-    given SingletonMethods as SingletonMethods = SingletonMethodsImpl
+    given SingletonMethods: SingletonMethods = SingletonMethodsImpl
 
     /** Implementation of extension methods on `Singleton` */
     protected val SingletonMethodsImpl: SingletonMethods
@@ -1689,7 +1689,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Refined <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Refined` */
-    given RefinedTypeTest as TypeTest[Tree, Refined] = RefinedTypeTestImpl
+    given RefinedTypeTest: TypeTest[Tree, Refined] = RefinedTypeTestImpl
 
     /** Implementation of `RefinedTypeTest` */
     protected val RefinedTypeTestImpl: TypeTest[Tree, Refined]
@@ -1705,7 +1705,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Refined` available without any imports */
-    given RefinedMethods as RefinedMethods = RefinedMethodsImpl
+    given RefinedMethods: RefinedMethods = RefinedMethodsImpl
 
     /** Implementation of extension methods on `Refined` */
     protected val RefinedMethodsImpl: RefinedMethods
@@ -1722,7 +1722,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Applied <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Applied` */
-    given AppliedTypeTest as TypeTest[Tree, Applied] = AppliedTypeTestImpl
+    given AppliedTypeTest: TypeTest[Tree, Applied] = AppliedTypeTestImpl
 
     /** Implementation of `AppliedTypeTest` */
     protected val AppliedTypeTestImpl: TypeTest[Tree, Applied]
@@ -1738,7 +1738,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Applied` available without any imports */
-    given AppliedMethods as AppliedMethods = AppliedMethodsImpl
+    given AppliedMethods: AppliedMethods = AppliedMethodsImpl
 
     /** Implementation of extension methods on `Applied` */
     protected val AppliedMethodsImpl: AppliedMethods
@@ -1755,7 +1755,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Annotated <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Annotated` */
-    given AnnotatedTypeTest as TypeTest[Tree, Annotated] = AnnotatedTypeTestImpl
+    given AnnotatedTypeTest: TypeTest[Tree, Annotated] = AnnotatedTypeTestImpl
 
     /** Implementation of `AnnotatedTypeTest` */
     protected val AnnotatedTypeTestImpl: TypeTest[Tree, Annotated]
@@ -1771,7 +1771,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Annotated` available without any imports */
-    given AnnotatedMethods as AnnotatedMethods = AnnotatedMethodsImpl
+    given AnnotatedMethods: AnnotatedMethods = AnnotatedMethodsImpl
 
     /** Implementation of extension methods on `Annotated` */
     protected val AnnotatedMethodsImpl: AnnotatedMethods
@@ -1788,7 +1788,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type MatchTypeTree <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `MatchTypeTree` */
-    given MatchTypeTreeTypeTest as TypeTest[Tree, MatchTypeTree] = MatchTypeTreeTypeTestImpl
+    given MatchTypeTreeTypeTest: TypeTest[Tree, MatchTypeTree] = MatchTypeTreeTypeTestImpl
 
     /** Implementation of `MatchTypeTreeTypeTest` */
     protected val MatchTypeTreeTypeTestImpl: TypeTest[Tree, MatchTypeTree]
@@ -1804,7 +1804,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `MatchTypeTree` available without any imports */
-    given MatchTypeTreeMethods as MatchTypeTreeMethods = MatchTypeTreeMethodsImpl
+    given MatchTypeTreeMethods: MatchTypeTreeMethods = MatchTypeTreeMethodsImpl
 
     /** Implementation of extension methods on `MatchTypeTree` */
     protected val MatchTypeTreeMethodsImpl: MatchTypeTreeMethods
@@ -1822,7 +1822,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ByName <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `ByName` */
-    given ByNameTypeTest as TypeTest[Tree, ByName] = ByNameTypeTestImpl
+    given ByNameTypeTest: TypeTest[Tree, ByName] = ByNameTypeTestImpl
 
     /** Implementation of `ByNameTypeTest` */
     protected val ByNameTypeTestImpl: TypeTest[Tree, ByName]
@@ -1838,7 +1838,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ByName` available without any imports */
-    given ByNameMethods as ByNameMethods = ByNameMethodsImpl
+    given ByNameMethods: ByNameMethods = ByNameMethodsImpl
 
     /** Implementation of extension methods on `ByName` */
     protected val ByNameMethodsImpl: ByNameMethods
@@ -1854,7 +1854,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type LambdaTypeTree <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `LambdaTypeTree` */
-    given LambdaTypeTreeTypeTest as TypeTest[Tree, LambdaTypeTree] = LambdaTypeTreeTypeTestImpl
+    given LambdaTypeTreeTypeTest: TypeTest[Tree, LambdaTypeTree] = LambdaTypeTreeTypeTestImpl
 
     /** Implementation of `LambdaTypeTreeTypeTest` */
     protected val LambdaTypeTreeTypeTestImpl: TypeTest[Tree, LambdaTypeTree]
@@ -1870,7 +1870,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `LambdaTypeTree` available without any imports */
-    given LambdaTypeTreeMethods as LambdaTypeTreeMethods = LambdaTypeTreeMethodsImpl
+    given LambdaTypeTreeMethods: LambdaTypeTreeMethods = LambdaTypeTreeMethodsImpl
 
     /** Implementation of extension methods on `LambdaTypeTree` */
     protected val LambdaTypeTreeMethodsImpl: LambdaTypeTreeMethods
@@ -1887,7 +1887,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeBind <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeBind` */
-    given TypeBindTypeTest as TypeTest[Tree, TypeBind] = TypeBindTypeTestImpl
+    given TypeBindTypeTest: TypeTest[Tree, TypeBind] = TypeBindTypeTestImpl
 
     /** Implementation of `TypeBindTypeTest` */
     protected val TypeBindTypeTestImpl: TypeTest[Tree, TypeBind]
@@ -1903,7 +1903,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeBind` available without any imports */
-    given TypeBindMethods as TypeBindMethods = TypeBindMethodsImpl
+    given TypeBindMethods: TypeBindMethods = TypeBindMethodsImpl
 
     /** Implementation of extension methods on `TypeBind` */
     protected val TypeBindMethodsImpl: TypeBindMethods
@@ -1920,7 +1920,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeBlock <: TypeTree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeBlock` */
-    given TypeBlockTypeTest as TypeTest[Tree, TypeBlock] = TypeBlockTypeTestImpl
+    given TypeBlockTypeTest: TypeTest[Tree, TypeBlock] = TypeBlockTypeTestImpl
 
     /** Implementation of `TypeBlockTypeTest` */
     protected val TypeBlockTypeTestImpl: TypeTest[Tree, TypeBlock]
@@ -1936,7 +1936,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeBlock` available without any imports */
-    given TypeBlockMethods as TypeBlockMethods = TypeBlockMethodsImpl
+    given TypeBlockMethods: TypeBlockMethods = TypeBlockMethodsImpl
 
     /** Implementation of extension methods on `TypeBlock` */
     protected val TypeBlockMethodsImpl: TypeBlockMethods
@@ -1955,7 +1955,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeBoundsTree <: Tree /*TypeTree | TypeBoundsTree*/
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeBoundsTree` */
-    given TypeBoundsTreeTypeTest as TypeTest[Tree, TypeBoundsTree] = TypeBoundsTreeTypeTestImpl
+    given TypeBoundsTreeTypeTest: TypeTest[Tree, TypeBoundsTree] = TypeBoundsTreeTypeTestImpl
 
     /** Implementation of `TypeBoundsTreeTypeTest` */
     protected val TypeBoundsTreeTypeTestImpl: TypeTest[Tree, TypeBoundsTree]
@@ -1971,7 +1971,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeBoundsTree` available without any imports */
-    given TypeBoundsTreeMethods as TypeBoundsTreeMethods = TypeBoundsTreeMethodsImpl
+    given TypeBoundsTreeMethods: TypeBoundsTreeMethods = TypeBoundsTreeMethodsImpl
 
     /** Implementation of extension methods on `TypeBoundsTree` */
     protected val TypeBoundsTreeMethodsImpl: TypeBoundsTreeMethods
@@ -1992,7 +1992,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type WildcardTypeTree  <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `WildcardTypeTree` */
-    given WildcardTypeTreeTypeTest as TypeTest[Tree, WildcardTypeTree] = WildcardTypeTreeTypeTestImpl
+    given WildcardTypeTreeTypeTest: TypeTest[Tree, WildcardTypeTree] = WildcardTypeTreeTypeTestImpl
 
     /** Implementation of `WildcardTypeTreeTypeTest` */
     protected val WildcardTypeTreeTypeTestImpl: TypeTest[Tree, WildcardTypeTree]
@@ -2008,7 +2008,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `WildcardTypeTree` available without any imports */
-    given WildcardTypeTreeMethods as WildcardTypeTreeMethods = WildcardTypeTreeMethodsImpl
+    given WildcardTypeTreeMethods: WildcardTypeTreeMethods = WildcardTypeTreeMethodsImpl
 
     /** Implementation of extension methods on `WildcardTypeTree` */
     protected val WildcardTypeTreeMethodsImpl: WildcardTypeTreeMethods
@@ -2026,7 +2026,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type CaseDef <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `CaseDef` */
-    given CaseDefTypeTest as TypeTest[Tree, CaseDef] = CaseDefTypeTestImpl
+    given CaseDefTypeTest: TypeTest[Tree, CaseDef] = CaseDefTypeTestImpl
 
     /** Implementation of `CaseDefTypeTest` */
     protected val CaseDefTypeTestImpl: TypeTest[Tree, CaseDef]
@@ -2042,7 +2042,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `CaseDef` available without any imports */
-    given CaseDefMethods as CaseDefMethods = CaseDefMethodsImpl
+    given CaseDefMethods: CaseDefMethods = CaseDefMethodsImpl
 
     /** Implementation of extension methods on `CaseDef` */
     protected val CaseDefMethodsImpl: CaseDefMethods
@@ -2060,7 +2060,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeCaseDef <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `TypeCaseDef` */
-    given TypeCaseDefTypeTest as TypeTest[Tree, TypeCaseDef] = TypeCaseDefTypeTestImpl
+    given TypeCaseDefTypeTest: TypeTest[Tree, TypeCaseDef] = TypeCaseDefTypeTestImpl
 
     /** Implementation of `TypeCaseDefTypeTest` */
     protected val TypeCaseDefTypeTestImpl: TypeTest[Tree, TypeCaseDef]
@@ -2076,7 +2076,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeCaseDef` available without any imports */
-    given TypeCaseDefMethods as TypeCaseDefMethods = TypeCaseDefMethodsImpl
+    given TypeCaseDefMethods: TypeCaseDefMethods = TypeCaseDefMethodsImpl
 
     /** Implementation of extension methods on `TypeCaseDef` */
     protected val TypeCaseDefMethodsImpl: TypeCaseDefMethods
@@ -2095,7 +2095,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Bind <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is a `Bind` */
-    given BindTypeTest as TypeTest[Tree, Bind] = BindTypeTestImpl
+    given BindTypeTest: TypeTest[Tree, Bind] = BindTypeTestImpl
 
     /** Implementation of `BindTypeTest` */
     protected val BindTypeTestImpl: TypeTest[Tree, Bind]
@@ -2111,7 +2111,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Bind` available without any imports */
-    given BindMethods as BindMethods = BindMethodsImpl
+    given BindMethods: BindMethods = BindMethodsImpl
 
     /** Implementation of extension methods on `Bind` */
     protected val BindMethodsImpl: BindMethods
@@ -2128,7 +2128,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Unapply <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Unapply` */
-    given UnapplyTypeTest as TypeTest[Tree, Unapply] = UnapplyTypeTestImpl
+    given UnapplyTypeTest: TypeTest[Tree, Unapply] = UnapplyTypeTestImpl
 
     /** Implementation of `UnapplyTypeTest` */
     protected val UnapplyTypeTestImpl: TypeTest[Tree, Unapply]
@@ -2144,7 +2144,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Unapply` available without any imports */
-    given UnapplyMethods as UnapplyMethods = UnapplyMethodsImpl
+    given UnapplyMethods: UnapplyMethods = UnapplyMethodsImpl
 
     /** Implementation of extension methods on `Unapply` */
     protected val UnapplyMethodsImpl: UnapplyMethods
@@ -2162,7 +2162,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Alternatives <: Tree
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `Alternatives` */
-    given AlternativesTypeTest as TypeTest[Tree, Alternatives] = AlternativesTypeTestImpl
+    given AlternativesTypeTest: TypeTest[Tree, Alternatives] = AlternativesTypeTestImpl
 
     /** Implementation of `AlternativesTypeTest` */
     protected val AlternativesTypeTestImpl: TypeTest[Tree, Alternatives]
@@ -2178,7 +2178,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Alternatives` available without any imports */
-    given AlternativesMethods as AlternativesMethods = AlternativesMethodsImpl
+    given AlternativesMethods: AlternativesMethods = AlternativesMethodsImpl
 
     /** Implementation of extension methods on `Alternatives` */
     protected val AlternativesMethodsImpl: AlternativesMethods
@@ -2212,7 +2212,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type SimpleSelector <: ImportSelector
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImportSelector` is a `SimpleSelector` */
-    given SimpleSelectorTypeTest as TypeTest[ImportSelector, SimpleSelector] = SimpleSelectorTypeTestImpl
+    given SimpleSelectorTypeTest: TypeTest[ImportSelector, SimpleSelector] = SimpleSelectorTypeTestImpl
 
     /** Implementation of `SimpleSelectorTypeTest` */
     protected val SimpleSelectorTypeTestImpl: TypeTest[ImportSelector, SimpleSelector]
@@ -2226,7 +2226,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `SimpleSelector` available without any imports */
-    given SimpleSelectorMethods as SimpleSelectorMethods = SimpleSelectorMethodsImpl
+    given SimpleSelectorMethods: SimpleSelectorMethods = SimpleSelectorMethodsImpl
 
     /** Implementation of extension methods on `SimpleSelector` */
     protected val SimpleSelectorMethodsImpl: SimpleSelectorMethods
@@ -2243,7 +2243,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type RenameSelector <: ImportSelector
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImportSelector` is a `RenameSelector` */
-    given RenameSelectorTypeTest as TypeTest[ImportSelector, RenameSelector] = RenameSelectorTypeTestImpl
+    given RenameSelectorTypeTest: TypeTest[ImportSelector, RenameSelector] = RenameSelectorTypeTestImpl
 
     /** Implementation of `RenameSelectorTypeTest` */
     protected val RenameSelectorTypeTestImpl: TypeTest[ImportSelector, RenameSelector]
@@ -2257,7 +2257,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `RenameSelector` available without any imports */
-    given RenameSelectorMethods as RenameSelectorMethods = RenameSelectorMethodsImpl
+    given RenameSelectorMethods: RenameSelectorMethods = RenameSelectorMethodsImpl
 
     /** Implementation of extension methods on `RenameSelector` */
     protected val RenameSelectorMethodsImpl: RenameSelectorMethods
@@ -2276,7 +2276,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type OmitSelector <: ImportSelector
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImportSelector` is an `OmitSelector` */
-    given OmitSelectorTypeTest as TypeTest[ImportSelector, OmitSelector] = OmitSelectorTypeTestImpl
+    given OmitSelectorTypeTest: TypeTest[ImportSelector, OmitSelector] = OmitSelectorTypeTestImpl
 
     /** Implementation of `OmitSelectorTypeTest` */
     protected val OmitSelectorTypeTestImpl: TypeTest[ImportSelector, OmitSelector]
@@ -2290,7 +2290,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `OmitSelector` available without any imports */
-    given OmitSelectorMethods as OmitSelectorMethods = OmitSelectorMethodsImpl
+    given OmitSelectorMethods: OmitSelectorMethods = OmitSelectorMethodsImpl
 
     /** Implementation of extension methods on `OmitSelector` */
     protected val OmitSelectorMethodsImpl: OmitSelectorMethods
@@ -2306,7 +2306,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type GivenSelector <: ImportSelector
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImportSelector` is a `GivenSelector` */
-    given GivenSelectorTypeTest as TypeTest[ImportSelector, GivenSelector] = GivenSelectorTypeTestImpl
+    given GivenSelectorTypeTest: TypeTest[ImportSelector, GivenSelector] = GivenSelectorTypeTestImpl
 
     /** Implementation of `GivenSelectorTypeTest` */
     protected val GivenSelectorTypeTestImpl: TypeTest[ImportSelector, GivenSelector]
@@ -2320,7 +2320,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `GivenSelector` available without any imports */
-    given GivenSelectorMethods as GivenSelectorMethods = GivenSelectorMethodsImpl
+    given GivenSelectorMethods: GivenSelectorMethods = GivenSelectorMethodsImpl
 
     /** Implementation of extension methods on `GivenSelector` */
     protected val GivenSelectorMethodsImpl: GivenSelectorMethods
@@ -2353,7 +2353,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeRepr` available without any imports */
-    given TypeReprMethods as TypeReprMethods = TypeReprMethodsImpl
+    given TypeReprMethods: TypeReprMethods = TypeReprMethodsImpl
 
     /** Implementation of extension methods on `TypeRepr` */
     protected val TypeReprMethodsImpl: TypeReprMethods
@@ -2487,7 +2487,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ConstantType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `ConstantType` */
-    given ConstantTypeTypeTest as TypeTest[TypeRepr, ConstantType] = ConstantTypeTypeTestImpl
+    given ConstantTypeTypeTest: TypeTest[TypeRepr, ConstantType] = ConstantTypeTypeTestImpl
 
     /** Implementation of `ConstantTypeTypeTest` */
     protected val ConstantTypeTypeTestImpl: TypeTest[TypeRepr, ConstantType]
@@ -2502,7 +2502,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ConstantType` available without any imports */
-    given ConstantTypeMethods as ConstantTypeMethods = ConstantTypeMethodsImpl
+    given ConstantTypeMethods: ConstantTypeMethods = ConstantTypeMethodsImpl
 
     /** Implementation of extension methods on `ConstantType` */
     protected val ConstantTypeMethodsImpl: ConstantTypeMethods
@@ -2518,7 +2518,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TermRef <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `TermRef` */
-    given TermRefTypeTest as TypeTest[TypeRepr, TermRef] = TermRefTypeTestImpl
+    given TermRefTypeTest: TypeTest[TypeRepr, TermRef] = TermRefTypeTestImpl
 
     /** Implementation of `TermRefTypeTest` */
     protected val TermRefTypeTestImpl: TypeTest[TypeRepr, TermRef]
@@ -2533,7 +2533,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TermRef` available without any imports */
-    given TermRefMethods as TermRefMethods = TermRefMethodsImpl
+    given TermRefMethods: TermRefMethods = TermRefMethodsImpl
 
     /** Implementation of extension methods on `TermRef` */
     protected val TermRefMethodsImpl: TermRefMethods
@@ -2550,7 +2550,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeRef <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `TypeRef` */
-    given TypeRefTypeTest as TypeTest[TypeRepr, TypeRef] = TypeRefTypeTestImpl
+    given TypeRefTypeTest: TypeTest[TypeRepr, TypeRef] = TypeRefTypeTestImpl
 
     /** Implementation of `TypeRefTypeTest` */
     protected val TypeRefTypeTestImpl: TypeTest[TypeRepr, TypeRef]
@@ -2564,7 +2564,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeRef` available without any imports */
-    given TypeRefMethods as TypeRefMethods = TypeRefMethodsImpl
+    given TypeRefMethods: TypeRefMethods = TypeRefMethodsImpl
 
     /** Implementation of extension methods on `TypeRef` */
     protected val TypeRefMethodsImpl: TypeRefMethods
@@ -2583,7 +2583,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type SuperType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `SuperType` */
-    given SuperTypeTypeTest as TypeTest[TypeRepr, SuperType] = SuperTypeTypeTestImpl
+    given SuperTypeTypeTest: TypeTest[TypeRepr, SuperType] = SuperTypeTypeTestImpl
 
     /** Implementation of `SuperTypeTypeTest` */
     protected val SuperTypeTypeTestImpl: TypeTest[TypeRepr, SuperType]
@@ -2598,7 +2598,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `SuperType` available without any imports */
-    given SuperTypeMethods as SuperTypeMethods = SuperTypeMethodsImpl
+    given SuperTypeMethods: SuperTypeMethods = SuperTypeMethodsImpl
 
     /** Implementation of extension methods on `SuperType` */
     protected val SuperTypeMethodsImpl: SuperTypeMethods
@@ -2615,7 +2615,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type Refinement <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `Refinement` */
-    given RefinementTypeTest as TypeTest[TypeRepr, Refinement] = RefinementTypeTestImpl
+    given RefinementTypeTest: TypeTest[TypeRepr, Refinement] = RefinementTypeTestImpl
 
     /** Implementation of `RefinementTypeTest` */
     protected val RefinementTypeTestImpl: TypeTest[TypeRepr, Refinement]
@@ -2630,7 +2630,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Refinement` available without any imports */
-    given RefinementMethods as RefinementMethods = RefinementMethodsImpl
+    given RefinementMethods: RefinementMethods = RefinementMethodsImpl
 
     /** Implementation of extension methods on `Refinement` */
     protected val RefinementMethodsImpl: RefinementMethods
@@ -2648,7 +2648,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type AppliedType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is an `AppliedType` */
-    given AppliedTypeTypeTest as TypeTest[TypeRepr, AppliedType] = AppliedTypeTypeTestImpl
+    given AppliedTypeTypeTest: TypeTest[TypeRepr, AppliedType] = AppliedTypeTypeTestImpl
 
     /** Implementation of `AppliedTypeTypeTest` */
     protected val AppliedTypeTypeTestImpl: TypeTest[TypeRepr, AppliedType]
@@ -2662,7 +2662,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `AppliedType` available without any imports */
-    given AppliedTypeMethods as AppliedTypeMethods = AppliedTypeMethodsImpl
+    given AppliedTypeMethods: AppliedTypeMethods = AppliedTypeMethodsImpl
 
     /** Implementation of extension methods on `AppliedType` */
     protected val AppliedTypeMethodsImpl: AppliedTypeMethods
@@ -2679,7 +2679,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type AnnotatedType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is an `AnnotatedType` */
-    given AnnotatedTypeTypeTest as TypeTest[TypeRepr, AnnotatedType] = AnnotatedTypeTypeTestImpl
+    given AnnotatedTypeTypeTest: TypeTest[TypeRepr, AnnotatedType] = AnnotatedTypeTypeTestImpl
 
     /** Implementation of `AnnotatedTypeTypeTest` */
     protected val AnnotatedTypeTypeTestImpl: TypeTest[TypeRepr, AnnotatedType]
@@ -2694,7 +2694,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `AnnotatedType` available without any imports */
-    given AnnotatedTypeMethods as AnnotatedTypeMethods = AnnotatedTypeMethodsImpl
+    given AnnotatedTypeMethods: AnnotatedTypeMethods = AnnotatedTypeMethodsImpl
 
     /** Implementation of extension methods on `AnnotatedType` */
     protected val AnnotatedTypeMethodsImpl: AnnotatedTypeMethods
@@ -2711,7 +2711,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type AndType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is an `AndType` */
-    given AndTypeTypeTest as TypeTest[TypeRepr, AndType] = AndTypeTypeTestImpl
+    given AndTypeTypeTest: TypeTest[TypeRepr, AndType] = AndTypeTypeTestImpl
 
     /** Implementation of `AndTypeTypeTest` */
     protected val AndTypeTypeTestImpl: TypeTest[TypeRepr, AndType]
@@ -2726,7 +2726,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `AndType` available without any imports */
-    given AndTypeMethods as AndTypeMethods = AndTypeMethodsImpl
+    given AndTypeMethods: AndTypeMethods = AndTypeMethodsImpl
 
     /** Implementation of extension methods on `AndType` */
     protected val AndTypeMethodsImpl: AndTypeMethods
@@ -2743,7 +2743,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type OrType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is an `OrType` */
-    given OrTypeTypeTest as TypeTest[TypeRepr, OrType] = OrTypeTypeTestImpl
+    given OrTypeTypeTest: TypeTest[TypeRepr, OrType] = OrTypeTypeTestImpl
 
     /** Implementation of `OrTypeTypeTest` */
     protected val OrTypeTypeTestImpl: TypeTest[TypeRepr, OrType]
@@ -2758,7 +2758,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `OrType` available without any imports */
-    given OrTypeMethods as OrTypeMethods = OrTypeMethodsImpl
+    given OrTypeMethods: OrTypeMethods = OrTypeMethodsImpl
 
     /** Implementation of extension methods on `OrType` */
     protected val OrTypeMethodsImpl: OrTypeMethods
@@ -2775,7 +2775,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type MatchType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `MatchType` */
-    given MatchTypeTypeTest as TypeTest[TypeRepr, MatchType] = MatchTypeTypeTestImpl
+    given MatchTypeTypeTest: TypeTest[TypeRepr, MatchType] = MatchTypeTypeTestImpl
 
     /** Implementation of `MatchTypeTypeTest` */
     protected val MatchTypeTypeTestImpl: TypeTest[TypeRepr, MatchType]
@@ -2790,7 +2790,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `MatchType` available without any imports */
-    given MatchTypeMethods as MatchTypeMethods = MatchTypeMethodsImpl
+    given MatchTypeMethods: MatchTypeMethods = MatchTypeMethodsImpl
 
     /** Implementation of extension methods on `MatchType` */
     protected val MatchTypeMethodsImpl: MatchTypeMethods
@@ -2808,7 +2808,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ByNameType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `ByNameType` */
-    given ByNameTypeTypeTest as TypeTest[TypeRepr, ByNameType] = ByNameTypeTypeTestImpl
+    given ByNameTypeTypeTest: TypeTest[TypeRepr, ByNameType] = ByNameTypeTypeTestImpl
 
     /** Implementation of `ByNameTypeTypeTest` */
     protected val ByNameTypeTypeTestImpl: TypeTest[TypeRepr, ByNameType]
@@ -2823,7 +2823,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ByNameType` available without any imports */
-    given ByNameTypeMethods as ByNameTypeMethods = ByNameTypeMethodsImpl
+    given ByNameTypeMethods: ByNameTypeMethods = ByNameTypeMethodsImpl
 
     /** Implementation of extension methods on `ByNameType` */
     protected val ByNameTypeMethodsImpl: ByNameTypeMethods
@@ -2839,7 +2839,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ParamRef <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `ParamRef` */
-    given ParamRefTypeTest as TypeTest[TypeRepr, ParamRef] = ParamRefTypeTestImpl
+    given ParamRefTypeTest: TypeTest[TypeRepr, ParamRef] = ParamRefTypeTestImpl
 
     /** Implementation of `ParamRefTypeTest` */
     protected val ParamRefTypeTestImpl: TypeTest[TypeRepr, ParamRef]
@@ -2853,7 +2853,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ParamRef` available without any imports */
-    given ParamRefMethods as ParamRefMethods = ParamRefMethodsImpl
+    given ParamRefMethods: ParamRefMethods = ParamRefMethodsImpl
 
     /** Implementation of extension methods on `ParamRef` */
     protected val ParamRefMethodsImpl: ParamRefMethods
@@ -2870,7 +2870,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ThisType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `ThisType` */
-    given ThisTypeTypeTest as TypeTest[TypeRepr, ThisType] = ThisTypeTypeTestImpl
+    given ThisTypeTypeTest: TypeTest[TypeRepr, ThisType] = ThisTypeTypeTestImpl
 
     /** Implementation of `ThisTypeTypeTest` */
     protected val ThisTypeTypeTestImpl: TypeTest[TypeRepr, ThisType]
@@ -2884,7 +2884,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `ThisType` available without any imports */
-    given ThisTypeMethods as ThisTypeMethods = ThisTypeMethodsImpl
+    given ThisTypeMethods: ThisTypeMethods = ThisTypeMethodsImpl
 
     /** Implementation of extension methods on `ThisType` */
     protected val ThisTypeMethodsImpl: ThisTypeMethods
@@ -2900,7 +2900,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type RecursiveThis <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `RecursiveThis` */
-    given RecursiveThisTypeTest as TypeTest[TypeRepr, RecursiveThis] = RecursiveThisTypeTestImpl
+    given RecursiveThisTypeTest: TypeTest[TypeRepr, RecursiveThis] = RecursiveThisTypeTestImpl
 
     /** Implementation of `RecursiveThisTypeTest` */
     protected val RecursiveThisTypeTestImpl: TypeTest[TypeRepr, RecursiveThis]
@@ -2914,7 +2914,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `RecursiveThis` available without any imports */
-    given RecursiveThisMethods as RecursiveThisMethods = RecursiveThisMethodsImpl
+    given RecursiveThisMethods: RecursiveThisMethods = RecursiveThisMethodsImpl
 
     /** Implementation of extension methods on `RecursiveThis` */
     protected val RecursiveThisMethodsImpl: RecursiveThisMethods
@@ -2930,7 +2930,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type RecursiveType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `RecursiveType` */
-    given RecursiveTypeTypeTest as TypeTest[TypeRepr, RecursiveType] = RecursiveTypeTypeTestImpl
+    given RecursiveTypeTypeTest: TypeTest[TypeRepr, RecursiveType] = RecursiveTypeTypeTestImpl
 
     /** Implementation of `RecursiveTypeTypeTest` */
     protected val RecursiveTypeTypeTestImpl: TypeTest[TypeRepr, RecursiveType]
@@ -2955,7 +2955,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `RecursiveType` available without any imports */
-    given RecursiveTypeMethods as RecursiveTypeMethods = RecursiveTypeMethodsImpl
+    given RecursiveTypeMethods: RecursiveTypeMethods = RecursiveTypeMethodsImpl
 
     /** Implementation of extension methods on `RecursiveType` */
     protected val RecursiveTypeMethodsImpl: RecursiveTypeMethods
@@ -2972,7 +2972,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type MethodType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `MethodType` */
-    given MethodTypeTypeTest as TypeTest[TypeRepr, MethodType] = MethodTypeTypeTestImpl
+    given MethodTypeTypeTest: TypeTest[TypeRepr, MethodType] = MethodTypeTypeTestImpl
 
     /** Implementation of `MethodTypeTypeTest` */
     protected val MethodTypeTypeTestImpl: TypeTest[TypeRepr, MethodType]
@@ -2987,7 +2987,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `MethodType` available without any imports */
-    given MethodTypeMethods as MethodTypeMethods = MethodTypeMethodsImpl
+    given MethodTypeMethods: MethodTypeMethods = MethodTypeMethodsImpl
 
     /** Implementation of extension methods on `MethodType` */
     protected val MethodTypeMethodsImpl: MethodTypeMethods
@@ -3008,7 +3008,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type PolyType <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `PolyType` */
-    given PolyTypeTypeTest as TypeTest[TypeRepr, PolyType] = PolyTypeTypeTestImpl
+    given PolyTypeTypeTest: TypeTest[TypeRepr, PolyType] = PolyTypeTypeTestImpl
 
     /** Implementation of `PolyTypeTypeTest` */
     protected val PolyTypeTypeTestImpl: TypeTest[TypeRepr, PolyType]
@@ -3023,7 +3023,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `PolyType` available without any imports */
-    given PolyTypeMethods as PolyTypeMethods = PolyTypeMethodsImpl
+    given PolyTypeMethods: PolyTypeMethods = PolyTypeMethodsImpl
 
     /** Implementation of extension methods on `PolyType` */
     protected val PolyTypeMethodsImpl: PolyTypeMethods
@@ -3042,7 +3042,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeLambda <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `TypeLambda` */
-    given TypeLambdaTypeTest as TypeTest[TypeRepr, TypeLambda] = TypeLambdaTypeTestImpl
+    given TypeLambdaTypeTest: TypeTest[TypeRepr, TypeLambda] = TypeLambdaTypeTestImpl
 
     /** Implementation of `TypeLambdaTypeTest` */
     protected val TypeLambdaTypeTestImpl: TypeTest[TypeRepr, TypeLambda]
@@ -3057,7 +3057,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeLambda` available without any imports */
-    given TypeLambdaMethods as TypeLambdaMethods = TypeLambdaMethodsImpl
+    given TypeLambdaMethods: TypeLambdaMethods = TypeLambdaMethodsImpl
 
     /** Implementation of extension methods on `TypeLambda` */
     protected val TypeLambdaMethodsImpl: TypeLambdaMethods
@@ -3078,7 +3078,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeBounds <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `TypeBounds` */
-    given TypeBoundsTypeTest as TypeTest[TypeRepr, TypeBounds] = TypeBoundsTypeTestImpl
+    given TypeBoundsTypeTest: TypeTest[TypeRepr, TypeBounds] = TypeBoundsTypeTestImpl
 
     /** Implementation of `TypeBoundsTypeTest` */
     protected val TypeBoundsTypeTestImpl: TypeTest[TypeRepr, TypeBounds]
@@ -3096,7 +3096,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `TypeBounds` available without any imports */
-    given TypeBoundsMethods as TypeBoundsMethods = TypeBoundsMethodsImpl
+    given TypeBoundsMethods: TypeBoundsMethods = TypeBoundsMethodsImpl
 
     /** Implementation of extension methods on `TypeBounds` */
     protected val TypeBoundsMethodsImpl: TypeBoundsMethods
@@ -3115,7 +3115,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type NoPrefix <: TypeRepr
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `NoPrefix` */
-    given NoPrefixTypeTest as TypeTest[TypeRepr, NoPrefix] = NoPrefixTypeTestImpl
+    given NoPrefixTypeTest: TypeTest[TypeRepr, NoPrefix] = NoPrefixTypeTestImpl
 
     /** Implementation of `NoPrefixTypeTest` */
     protected val NoPrefixTypeTestImpl: TypeTest[TypeRepr, NoPrefix]
@@ -3283,7 +3283,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Constant` available without any imports */
-    given ConstantMethods as ConstantMethods = ConstantMethodsImpl
+    given ConstantMethods: ConstantMethods = ConstantMethodsImpl
 
     /** Implementation of extension methods on `Constant` */
     protected val ConstantMethodsImpl: ConstantMethods
@@ -3329,7 +3329,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ImplicitSearchResult <: AnyRef
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is an `ImplicitSearchSuccess` */
-    given ImplicitSearchSuccessTypeTest as TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTestImpl
+    given ImplicitSearchSuccessTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTestImpl
 
     /** Implementation of `ImplicitSearchSuccessTypeTest` */
     protected val ImplicitSearchSuccessTypeTestImpl: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]
@@ -3337,7 +3337,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ImplicitSearchSuccess <: ImplicitSearchResult
 
     /** Makes extension methods on `ImplicitSearchSuccess` available without any imports */
-    given ImplicitSearchSuccessMethods as ImplicitSearchSuccessMethods = ImplicitSearchSuccessMethodsImpl
+    given ImplicitSearchSuccessMethods: ImplicitSearchSuccessMethods = ImplicitSearchSuccessMethodsImpl
 
     /** Implementation of extension methods on `ImplicitSearchSuccess` */
     protected val ImplicitSearchSuccessMethodsImpl: ImplicitSearchSuccessMethods
@@ -3352,13 +3352,13 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type ImplicitSearchFailure <: ImplicitSearchResult
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is an `ImplicitSearchFailure` */
-    given ImplicitSearchFailureTypeTest as TypeTest[ImplicitSearchResult, ImplicitSearchFailure] = ImplicitSearchFailureTypeTestImpl
+    given ImplicitSearchFailureTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchFailure] = ImplicitSearchFailureTypeTestImpl
 
     /** Implementation of `ImplicitSearchFailureTypeTest` */
     protected val ImplicitSearchFailureTypeTestImpl: TypeTest[ImplicitSearchResult, ImplicitSearchFailure]
 
     /** Makes extension methods on `ImplicitSearchFailure` available without any imports */
-    given ImplicitSearchFailureMethods as ImplicitSearchFailureMethods = ImplicitSearchFailureMethodsImpl
+    given ImplicitSearchFailureMethods: ImplicitSearchFailureMethods = ImplicitSearchFailureMethodsImpl
 
     /** Implementation of extension methods on `ImplicitSearchFailure` */
     protected val ImplicitSearchFailureMethodsImpl: ImplicitSearchFailureMethods
@@ -3373,7 +3373,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type DivergingImplicit <: ImplicitSearchFailure
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is a `DivergingImplicit` */
-    given DivergingImplicitTypeTest as TypeTest[ImplicitSearchResult, DivergingImplicit] = DivergingImplicitTypeTestImpl
+    given DivergingImplicitTypeTest: TypeTest[ImplicitSearchResult, DivergingImplicit] = DivergingImplicitTypeTestImpl
 
     /** Implementation of `DivergingImplicitTypeTest` */
     protected val DivergingImplicitTypeTestImpl: TypeTest[ImplicitSearchResult, DivergingImplicit]
@@ -3381,7 +3381,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type NoMatchingImplicits <: ImplicitSearchFailure
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is a `NoMatchingImplicits` */
-    given NoMatchingImplicitsTypeTest as TypeTest[ImplicitSearchResult, NoMatchingImplicits] = NoMatchingImplicitsTypeTestImpl
+    given NoMatchingImplicitsTypeTest: TypeTest[ImplicitSearchResult, NoMatchingImplicits] = NoMatchingImplicitsTypeTestImpl
 
     /** Implementation of `NoMatchingImplicitsTypeTest` */
     protected val NoMatchingImplicitsTypeTestImpl: TypeTest[ImplicitSearchResult, NoMatchingImplicits]
@@ -3389,7 +3389,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type AmbiguousImplicits <: ImplicitSearchFailure
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is an `AmbiguousImplicits` */
-    given AmbiguousImplicitsTypeTest as TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTestImpl
+    given AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTestImpl
 
     /** Implementation of `AmbiguousImplicitsTypeTest` */
     protected val AmbiguousImplicitsTypeTestImpl: TypeTest[ImplicitSearchResult, AmbiguousImplicits]
@@ -3485,7 +3485,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Symbol` available without any imports */
-    given SymbolMethods as SymbolMethods = SymbolMethodsImpl
+    given SymbolMethods: SymbolMethods = SymbolMethodsImpl
 
     /** Implementation of extension methods on `Symbol` */
     protected val SymbolMethodsImpl: SymbolMethods
@@ -3677,7 +3677,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Signature` available without any imports */
-    given SignatureMethods as SignatureMethods = SignatureMethodsImpl
+    given SignatureMethods: SignatureMethods = SignatureMethodsImpl
 
     /** Implementation of extension methods on `Signature` */
     protected val SignatureMethodsImpl: SignatureMethods
@@ -4004,7 +4004,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Flags` available without any imports */
-    given FlagsMethods as FlagsMethods = FlagsMethodsImpl
+    given FlagsMethods: FlagsMethods = FlagsMethodsImpl
 
     /** Implementation of extension methods on `Flags` */
     protected val FlagsMethodsImpl: FlagsMethods
@@ -4051,7 +4051,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** Makes extension methods on `Position` available without any imports */
-    given PositionMethods as PositionMethods = PositionMethodsImpl
+    given PositionMethods: PositionMethods = PositionMethodsImpl
 
     /** Implementation of extension methods on `Position` */
     protected val PositionMethodsImpl: PositionMethods
@@ -4100,7 +4100,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     trait SourceFileModule { this: SourceFile.type => }
 
     /** Makes extension methods on `SourceFile` available without any imports */
-    given SourceFileMethods as SourceFileMethods = SourceFileMethodsImpl
+    given SourceFileMethods: SourceFileMethods = SourceFileMethodsImpl
 
     /** Implementation of extension methods on `SourceFile` */
     protected val SourceFileMethodsImpl: SourceFileMethods
@@ -4194,7 +4194,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     trait DocumentationModule { this: Documentation.type => }
 
     /** Makes extension methods on `Documentation` available without any imports */
-    given DocumentationMethods as DocumentationMethods = DocumentationMethodsImpl
+    given DocumentationMethods: DocumentationMethods = DocumentationMethodsImpl
 
     /** Implementation of extension methods on `Documentation` */
     protected val DocumentationMethodsImpl: DocumentationMethods
diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala
index 1f1a10a15702..4b5d4c4fece1 100644
--- a/library/src/scala/quoted/Type.scala
+++ b/library/src/scala/quoted/Type.scala
@@ -25,6 +25,6 @@ object Type:
 
   /** Return a quoted.Type with the given type */
   @compileTimeOnly("Reference to `scala.quoted.Type.of` was not handled by PickleQuotes")
-  given of[T <: AnyKind] as (Quotes ?=> Type[T]) = ???
+  given of[T <: AnyKind]: (Quotes ?=> Type[T]) = ???
 
 end Type
diff --git a/library/src/scala/runtime/stdLibPatches/Predef.scala b/library/src/scala/runtime/stdLibPatches/Predef.scala
index 4c25c1febadf..fbadd3c9cdd9 100644
--- a/library/src/scala/runtime/stdLibPatches/Predef.scala
+++ b/library/src/scala/runtime/stdLibPatches/Predef.scala
@@ -29,7 +29,7 @@ object Predef:
   /** Summon a given value of type `T`. Usually, the argument is not passed explicitly.
    *
    *  @tparam T the type of the value to be summoned
-   *  @return the given value typed as the provided type parameter
+   *  @return the given value typed: the provided type parameter
    */
   inline def summon[T](using x: T): x.type = x
 
diff --git a/library/src/scala/util/FromDigits.scala b/library/src/scala/util/FromDigits.scala
index fd33c1883b7b..6064116d1443 100644
--- a/library/src/scala/util/FromDigits.scala
+++ b/library/src/scala/util/FromDigits.scala
@@ -156,11 +156,11 @@ object FromDigits {
     x
   }
 
-  given BigIntFromDigits as WithRadix[BigInt] {
+  given BigIntFromDigits: WithRadix[BigInt] with {
     def fromDigits(digits: String, radix: Int): BigInt = BigInt(digits, radix)
   }
 
-  given BigDecimalFromDigits as Floating[BigDecimal] {
+  given BigDecimalFromDigits: Floating[BigDecimal] with {
     def fromDigits(digits: String): BigDecimal = BigDecimal(digits)
   }
 }
diff --git a/library/src/scala/util/Not.scala b/library/src/scala/util/Not.scala
index 398b620747b8..849bd32dad71 100644
--- a/library/src/scala/util/Not.scala
+++ b/library/src/scala/util/Not.scala
@@ -27,7 +27,7 @@ final class Not[+T] private ()
 trait LowPriorityNot {
 
   /** A fallback method used to emulate negation in Scala 2 */
-  given default[T] as Not[T] = Not.value
+  given default[T]: Not[T] = Not.value
 }
 object Not extends LowPriorityNot {
 
@@ -38,8 +38,8 @@ object Not extends LowPriorityNot {
   def value: Not[Nothing] = new Not[Nothing]()
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  given amb1[T](using ev: T) as Not[T] = ???
+  given amb1[T](using ev: T): Not[T] = ???
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
-  given amb2[T](using ev: T) as Not[T] = ???
+  given amb2[T](using ev: T): Not[T] = ???
 }
diff --git a/scala3doc/src/dotty/dokka/DocContext.scala b/scala3doc/src/dotty/dokka/DocContext.scala
index 8470b909b69d..f016e6ff91bb 100644
--- a/scala3doc/src/dotty/dokka/DocContext.scala
+++ b/scala3doc/src/dotty/dokka/DocContext.scala
@@ -21,10 +21,10 @@ import scala.io.Codec
 
 type CompilerContext = dotty.tools.dotc.core.Contexts.Context
 
-given compilerContext(using docContext: DocContext) as CompilerContext =
+given compilerContext(using docContext: DocContext): CompilerContext =
   docContext.compilerContext
 
-given docContextFromDokka(using dokkaContext: DokkaContext) as DocContext =
+given docContextFromDokka(using dokkaContext: DokkaContext): DocContext =
   dokkaContext.getConfiguration.asInstanceOf[DocContext]
 
 val report = dotty.tools.dotc.report
diff --git a/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala b/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
index 11cc07f3be37..2282c19dfede 100644
--- a/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/ScalaDocSupport.scala
@@ -18,7 +18,7 @@ trait ScaladocSupport { self: TastyParser =>
     val commentNode =
       if tree.symbol.isClassDef || tree.symbol.owner.isClassDef then
         import dotty.tools.dotc
-        given ctx as dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+        given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
 
         val sym = tree.symbol.asInstanceOf[dotc.core.Symbols.Symbol]
 
diff --git a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
index da7accc67369..4e079931256e 100644
--- a/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/SyntheticSupport.scala
@@ -14,13 +14,13 @@ trait SyntheticsSupport:
 
     def hackIsTupleType(using Quotes)(rtpe: qctx.reflect.TypeRepr): Boolean =
       import dotty.tools.dotc
-      given ctx as dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+      given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
       val tpe = rtpe.asInstanceOf[dotc.core.Types.Type]
       ctx.definitions.isTupleType(tpe)
 
     def hackIsCompiletimeAppliedType(using Quotes)(rtpe: qctx.reflect.TypeRepr): Boolean =
       import dotty.tools.dotc
-      given ctx as dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+      given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
       val tpe = rtpe.asInstanceOf[dotc.core.Types.Type]
       ctx.definitions.isCompiletimeAppliedType(tpe.typeSymbol)
 
@@ -55,7 +55,7 @@ trait SyntheticsSupport:
   def hackIsInfix(using Quotes)(rsym: qctx.reflect.Symbol): Boolean = {
     import qctx.reflect._
     import dotty.tools.dotc
-    given ctx as dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+    given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     ctx.definitions.isInfix(sym)
   }
@@ -66,7 +66,7 @@ trait SyntheticsSupport:
   def hackGetAllMembers(using Quotes)(rsym: qctx.reflect.Symbol): List[qctx.reflect.Symbol] = {
     import qctx.reflect._
     import dotty.tools.dotc
-    given ctx as dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+    given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef)).allMembers.iterator.map(_.symbol)
       .collect {
diff --git a/scala3doc/src/dotty/dokka/tasty/TypesSupport.scala b/scala3doc/src/dotty/dokka/tasty/TypesSupport.scala
index 0408cdd081c6..a25fc15ec2f3 100644
--- a/scala3doc/src/dotty/dokka/tasty/TypesSupport.scala
+++ b/scala3doc/src/dotty/dokka/tasty/TypesSupport.scala
@@ -35,7 +35,7 @@ trait TypesSupport:
     }.flatten.map(_.dokkaType)
   }
 
-  given TreeSyntax as AnyRef:
+  given TreeSyntax: AnyRef with
     extension (tpeTree: Tree):
       def dokkaType: Bound =
         val data = tpeTree match
@@ -45,7 +45,7 @@ trait TypesSupport:
 
         new GenericTypeConstructor(tpeTree.symbol.dri, data.asJava, null)
 
-  given TypeSyntax as AnyRef:
+  given TypeSyntax: AnyRef with
     extension (tpe: TypeRepr):
       def dokkaType: Bound =
         val data = inner(tpe)
@@ -215,11 +215,11 @@ trait TypesSupport:
         //     case _ =>
         //     throw Exception("Match error in TypeRef. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(qual))
         // }
-      case tr @ TermRef(qual, typeName) => 
+      case tr @ TermRef(qual, typeName) =>
         tr.termSymbol.tree match
           case vd: ValDef => inner(vd.tpt.tpe)
           case _          => link(tr.termSymbol)
-        
+
 
         // convertTypeOrBoundsToReference(reflect)(qual) match {
         //     case TypeReference(label, link, xs, _) => TypeReference(typeName + "$", link + "/" + label, xs)
@@ -246,7 +246,7 @@ trait TypesSupport:
         inner(sc) ++ texts(" match {\n") ++ casesTexts ++ texts("}")
 
       case ParamRef(TypeLambda(names, _, _), i) => texts(names.apply(i))
-      
+
       case ParamRef(m: MethodType, i) => texts(m.paramNames(i))
 
       case RecursiveType(tp) => inner(tp)
diff --git a/scala3doc/test/dotty/dokka/tasty/comments/CommentExpanderTests.scala b/scala3doc/test/dotty/dokka/tasty/comments/CommentExpanderTests.scala
index 1dcaa6431523..0feeff3f0eb4 100644
--- a/scala3doc/test/dotty/dokka/tasty/comments/CommentExpanderTests.scala
+++ b/scala3doc/test/dotty/dokka/tasty/comments/CommentExpanderTests.scala
@@ -30,7 +30,7 @@ class CommentExpanderTests {
     str: String
   ): Unit =
     import dotty.tools.dotc
-    given ctx as dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
+    given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
     val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol]
     val comment = CommentExpander.cookComment(sym).get
     assertEquals(comment.expanded.get, str)
diff --git a/tests/neg-macros/i7919.scala b/tests/neg-macros/i7919.scala
index 9920eb0461dd..d3ff9dc96111 100644
--- a/tests/neg-macros/i7919.scala
+++ b/tests/neg-macros/i7919.scala
@@ -3,7 +3,7 @@ import scala.quoted._
 object Test {
   def staged[T](using Quotes) = {
     import quotes.reflect._
-    given typeT as Type[T] with {} // error
+    given typeT: Type[T] with {} // error
     val tt = TypeRepr.of[T]
     '{ "in staged" }
   }