diff --git a/community-build/community-projects/scodec b/community-build/community-projects/scodec
index 14dc7452241a..8d7f83ae76e3 160000
--- a/community-build/community-projects/scodec
+++ b/community-build/community-projects/scodec
@@ -1 +1 @@
-Subproject commit 14dc7452241a21dd1e8a62229e632332a3e3855e
+Subproject commit 8d7f83ae76e3278245631126d808c9c02e57ae23
diff --git a/community-build/community-projects/scodec-bits b/community-build/community-projects/scodec-bits
index c6dbf213f2e8..e0f4a8299c6f 160000
--- a/community-build/community-projects/scodec-bits
+++ b/community-build/community-projects/scodec-bits
@@ -1 +1 @@
-Subproject commit c6dbf213f2e8b442b0584af702ee830579147993
+Subproject commit e0f4a8299c6fafe422d6f6bae470484ba4b50e00
diff --git a/community-build/community-projects/shapeless b/community-build/community-projects/shapeless
index 430ace1c1ee7..f891242ed245 160000
--- a/community-build/community-projects/shapeless
+++ b/community-build/community-projects/shapeless
@@ -1 +1 @@
-Subproject commit 430ace1c1ee7390c91698547d08de251415ecd49
+Subproject commit f891242ed245c3b88d0b9889d64b122a5a50a4d0
diff --git a/community-build/community-projects/xml-interpolator b/community-build/community-projects/xml-interpolator
index 8d6da2215cb9..9f30c806e644 160000
--- a/community-build/community-projects/xml-interpolator
+++ b/community-build/community-projects/xml-interpolator
@@ -1 +1 @@
-Subproject commit 8d6da2215cb9bfeca26d885583b3b96941a0f008
+Subproject commit 9f30c806e644a0172985a99e282d764a5a338037
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/backend/sjs/JSExportsGen.scala b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
index 2308efd6a0b1..7e7837bd3ac0 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
@@ -942,7 +942,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
   private case object NoTypeTest extends RTTypeTest
 
   private object RTTypeTest {
-    given PartialOrdering[RTTypeTest] {
+    given PartialOrdering[RTTypeTest] with {
       override def tryCompare(lhs: RTTypeTest, rhs: RTTypeTest): Option[Int] = {
         if (lteq(lhs, rhs)) if (lteq(rhs, lhs)) Some(0) else Some(-1)
         else                if (lteq(rhs, lhs)) Some(1) else None
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/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index f6e2ecd347bc..95d819065ba4 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -913,7 +913,7 @@ object Parsers {
           lookahead.nextToken()
           skipParams()
       skipParams()
-      lookahead.token == COLON || lookahead.isIdent(nme.as)
+      lookahead.token == COLON
 
     def followingIsExtension() =
       val next = in.lookahead.token
@@ -3517,9 +3517,8 @@ object Parsers {
      */
     def givenDef(start: Offset, mods: Modifiers, givenMod: Mod) = atSpan(start, nameStart) {
       var mods1 = addMod(mods, givenMod)
-      val hasGivenSig = followingIsGivenSig()
       val nameStart = in.offset
-      val name = if isIdent && hasGivenSig then ident() else EmptyTermName
+      val name = if isIdent && followingIsGivenSig() then ident() else EmptyTermName
 
       val gdef =
         val tparams = typeParamClauseOpt(ParamOwner.Def)
@@ -3530,10 +3529,7 @@ object Parsers {
           else Nil
         newLinesOpt()
         val noParams = tparams.isEmpty && vparamss.isEmpty
-        val newSyntax = in.token == COLON
-        if !(name.isEmpty && noParams) then
-          if isIdent(nme.as) then in.nextToken()
-          else accept(COLON)
+        if !(name.isEmpty && noParams) then accept(COLON)
         val parents = constrApp() :: withConstrApps()
         val parentsIsType = parents.length == 1 && parents.head.isType
         if in.token == EQUALS && parentsIsType then
@@ -3544,7 +3540,7 @@ object Parsers {
             ValDef(name, parents.head, subExpr())
           else
             DefDef(name, tparams, vparamss, parents.head, subExpr())
-        else if newSyntax && in.token != WITH && in.token != WITHEOL && parentsIsType then
+        else if in.token != WITH && in.token != WITHEOL && parentsIsType then
           if name.isEmpty then
             syntaxError(em"anonymous given cannot be abstract")
           DefDef(name, tparams, vparamss, parents.head, EmptyTree)
@@ -3552,14 +3548,8 @@ object Parsers {
           val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
           val vparamss1 = vparamss.map(_.map(vparam =>
             vparam.withMods(vparam.mods &~ Param | ParamAccessor | Protected)))
-          val constr = makeConstructor(tparams1, vparamss1)
-          val templ =
-            if newSyntax || in.token == WITHEOL || in.token == WITH then
-              withTemplate(constr, parents)
-            else
-              possibleTemplateStart()
-              templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil)
-          if tparams.isEmpty && vparamss.isEmpty then ModuleDef(name, templ)
+          val templ = withTemplate(makeConstructor(tparams1, vparamss1), parents)
+          if noParams then ModuleDef(name, templ)
           else TypeDef(name.toTypeName, templ)
       end gdef
       finalizeDef(gdef, mods1, start)
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/language-server/test/dotty/tools/languageserver/CompletionTest.scala b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
index 5383186c3593..d58ab87b8174 100644
--- a/language-server/test/dotty/tools/languageserver/CompletionTest.scala
+++ b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
@@ -361,7 +361,7 @@ class CompletionTest {
   @Test def completeExtensionMethodFromGivenInstanceDefinedInScope: Unit = {
     code"""object Foo
           |trait FooOps
-          |given FooOps {
+          |given FooOps with {
           |  extension (foo: Foo.type) def xxxx = 1
           |}
           |object Main { Foo.xx${m1} }""".withSource
@@ -372,7 +372,7 @@ class CompletionTest {
     code"""object Foo
           |trait FooOps
           |object Bar {
-          |  given FooOps {
+          |  given FooOps with {
           |    extension (foo: Foo.type) def xxxx = 1
           |  }
           |}
@@ -394,7 +394,7 @@ class CompletionTest {
     code"""trait Bar
           |case class Foo(i: Int)
           |object Foo {
-          |  given Bar {
+          |  given Bar with {
           |    extension (foo: Foo) def xxxx = foo.i
           |  }
           |}
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 a8dd2317e5d8..1c6095b81899 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -197,7 +197,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
@@ -246,7 +246,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]
@@ -262,7 +262,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
@@ -279,7 +279,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]
@@ -295,7 +295,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
@@ -312,7 +312,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]
@@ -323,7 +323,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]
@@ -335,7 +335,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
@@ -353,7 +353,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]
@@ -369,7 +369,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
@@ -391,7 +391,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]
@@ -407,7 +407,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
@@ -428,7 +428,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]
@@ -454,7 +454,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
@@ -473,7 +473,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]
@@ -489,7 +489,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
@@ -508,7 +508,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]
@@ -536,7 +536,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
@@ -594,7 +594,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]
@@ -629,7 +629,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]
@@ -648,7 +648,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
@@ -664,7 +664,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]
@@ -698,7 +698,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
@@ -713,7 +713,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]
@@ -737,7 +737,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
@@ -753,7 +753,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]
@@ -774,7 +774,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
@@ -790,7 +790,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]
@@ -811,7 +811,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
@@ -827,7 +827,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]
@@ -848,7 +848,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
@@ -865,7 +865,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]
@@ -886,7 +886,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
@@ -903,7 +903,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]
@@ -924,7 +924,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
@@ -938,7 +938,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]
@@ -962,7 +962,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
@@ -977,7 +977,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]
@@ -1001,7 +1001,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
@@ -1018,7 +1018,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]
@@ -1039,7 +1039,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
@@ -1056,7 +1056,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]
@@ -1077,7 +1077,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
@@ -1091,7 +1091,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]
@@ -1121,7 +1121,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
@@ -1171,7 +1171,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]
@@ -1195,7 +1195,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
@@ -1213,7 +1213,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]
@@ -1234,7 +1234,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
@@ -1251,7 +1251,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]
@@ -1272,7 +1272,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
@@ -1288,7 +1288,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]
@@ -1309,7 +1309,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
@@ -1324,7 +1324,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]
@@ -1348,7 +1348,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
@@ -1365,7 +1365,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]
@@ -1381,7 +1381,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
@@ -1398,7 +1398,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]
@@ -1414,7 +1414,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
@@ -1432,7 +1432,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]
@@ -1448,7 +1448,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
@@ -1466,7 +1466,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]
@@ -1487,7 +1487,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
@@ -1506,7 +1506,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]
@@ -1521,7 +1521,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
@@ -1538,7 +1538,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]
@@ -1557,7 +1557,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]
@@ -1573,7 +1573,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
@@ -1589,7 +1589,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]
@@ -1605,7 +1605,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
@@ -1622,7 +1622,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]
@@ -1638,7 +1638,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
@@ -1655,7 +1655,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]
@@ -1671,7 +1671,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
@@ -1687,7 +1687,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]
@@ -1703,7 +1703,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
@@ -1720,7 +1720,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]
@@ -1736,7 +1736,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
@@ -1753,7 +1753,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]
@@ -1769,7 +1769,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
@@ -1786,7 +1786,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]
@@ -1802,7 +1802,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
@@ -1820,7 +1820,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]
@@ -1836,7 +1836,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
@@ -1852,7 +1852,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]
@@ -1868,7 +1868,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
@@ -1885,7 +1885,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]
@@ -1901,7 +1901,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
@@ -1918,7 +1918,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]
@@ -1934,7 +1934,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
@@ -1953,7 +1953,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]
@@ -1969,7 +1969,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
@@ -1990,7 +1990,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]
@@ -2006,7 +2006,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
@@ -2024,7 +2024,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]
@@ -2040,7 +2040,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
@@ -2058,7 +2058,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]
@@ -2074,7 +2074,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
@@ -2093,7 +2093,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]
@@ -2109,7 +2109,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
@@ -2126,7 +2126,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]
@@ -2142,7 +2142,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
@@ -2160,7 +2160,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]
@@ -2176,7 +2176,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
@@ -2210,7 +2210,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]
@@ -2224,7 +2224,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
@@ -2241,7 +2241,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]
@@ -2255,7 +2255,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
@@ -2274,7 +2274,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]
@@ -2288,7 +2288,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
@@ -2304,7 +2304,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]
@@ -2318,7 +2318,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
@@ -2351,7 +2351,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
@@ -2485,7 +2485,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]
@@ -2500,7 +2500,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
@@ -2516,7 +2516,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]
@@ -2531,7 +2531,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
@@ -2548,7 +2548,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]
@@ -2562,7 +2562,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
@@ -2581,7 +2581,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]
@@ -2596,7 +2596,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
@@ -2613,7 +2613,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]
@@ -2628,7 +2628,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
@@ -2646,7 +2646,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]
@@ -2660,7 +2660,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
@@ -2677,7 +2677,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]
@@ -2692,7 +2692,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
@@ -2709,7 +2709,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]
@@ -2724,7 +2724,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
@@ -2741,7 +2741,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]
@@ -2756,7 +2756,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
@@ -2773,7 +2773,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]
@@ -2788,7 +2788,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
@@ -2806,7 +2806,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]
@@ -2821,7 +2821,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
@@ -2837,7 +2837,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]
@@ -2851,7 +2851,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
@@ -2868,7 +2868,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]
@@ -2882,7 +2882,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
@@ -2898,7 +2898,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]
@@ -2912,7 +2912,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
@@ -2928,7 +2928,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]
@@ -2953,7 +2953,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
@@ -2970,7 +2970,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]
@@ -2985,7 +2985,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
@@ -3006,7 +3006,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]
@@ -3021,7 +3021,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
@@ -3040,7 +3040,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]
@@ -3055,7 +3055,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
@@ -3076,7 +3076,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]
@@ -3094,7 +3094,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
@@ -3113,7 +3113,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]
@@ -3281,7 +3281,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
@@ -3327,7 +3327,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]
@@ -3335,7 +3335,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
@@ -3350,13 +3350,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
@@ -3371,7 +3371,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]
@@ -3379,7 +3379,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]
@@ -3387,7 +3387,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]
@@ -3483,7 +3483,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
@@ -3675,7 +3675,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
@@ -4002,7 +4002,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
@@ -4049,7 +4049,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
@@ -4098,7 +4098,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
@@ -4192,7 +4192,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/CommandLineParser.scala b/library/src/scala/util/CommandLineParser.scala
index 5b0c49b483e6..fd239ef231c5 100644
--- a/library/src/scala/util/CommandLineParser.scala
+++ b/library/src/scala/util/CommandLineParser.scala
@@ -54,36 +54,28 @@ object CommandLineParser {
   }
 
   object FromString {
-    given FromString[String] {
+    given FromString[String] with
       def fromString(s: String) = s
-    }
 
-    given FromString[Boolean] {
+    given FromString[Boolean] with
       def fromString(s: String) = s.toBoolean
-    }
 
-    given FromString[Byte] {
+    given FromString[Byte] with
       def fromString(s: String) = s.toByte
-    }
 
-    given FromString[Short] {
+    given FromString[Short] with
       def fromString(s: String) = s.toShort
-    }
 
-    given FromString[Int] {
+    given FromString[Int] with
       def fromString(s: String) = s.toInt
-    }
 
-    given FromString[Long] {
+    given FromString[Long] with
       def fromString(s: String) = s.toLong
-    }
 
-    given FromString[Float] {
+    given FromString[Float] with
       def fromString(s: String) = s.toFloat
-    }
 
-    given FromString[Double] {
+    given FromString[Double] with
       def fromString(s: String) = s.toDouble
-    }
   }
 }
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/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/Conversion.scala b/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/Conversion.scala
index abaf0943a51a..87e8e8e1829c 100644
--- a/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/Conversion.scala
+++ b/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/Conversion.scala
@@ -12,7 +12,7 @@ object Conversion {
 
   def convert[T, U](x: T)(using converter: Conversion[T, U]): U = converter(x)
 
-  given IntWrapperToDoubleWrapper as Conversion[IntWrapper, DoubleWrapper] = new Conversion[IntWrapper, DoubleWrapper] {
+  given IntWrapperToDoubleWrapper: Conversion[IntWrapper, DoubleWrapper] = new Conversion[IntWrapper, DoubleWrapper] {
     override def apply(i: IntWrapper): DoubleWrapper = new DoubleWrapper(i.a.toDouble)
   }
 
diff --git a/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/ImpliedInstances.scala b/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/ImpliedInstances.scala
index 8db09da27477..ab76f9732529 100644
--- a/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/ImpliedInstances.scala
+++ b/sbt-dotty/sbt-test/sbt-dotty/scala3doc/src/main/scala/ImpliedInstances.scala
@@ -20,10 +20,10 @@ object ImpliedInstances {
       override def parse(s: String): Try[A] = f(s)
     }
 
-    given stringParser as StringParser[String] = baseParser(Success(_))
-    given intParser as StringParser[Int] = baseParser(s ⇒ Try(s.toInt))
+    given stringParser: StringParser[String] = baseParser(Success(_))
+    given intParser: StringParser[Int] = baseParser(s ⇒ Try(s.toInt))
 
-    given optionParser[A](using parser: => StringParser[A]) as StringParser[Option[A]] = new StringParser[Option[A]] {
+    given optionParser[A](using parser: => StringParser[A]): StringParser[Option[A]] = new StringParser[Option[A]] {
       override def parse(s: String): Try[Option[A]] = s match {
         case "" ⇒ Success(None) // implicit parser not used.
         case str ⇒ parser.parse(str).map(x ⇒ Some(x)) // implicit parser is evaluated at here
diff --git a/scala3doc-testcases/src/tests/givenDRI.scala b/scala3doc-testcases/src/tests/givenDRI.scala
index 8ae70668d869..819aa228c53b 100644
--- a/scala3doc-testcases/src/tests/givenDRI.scala
+++ b/scala3doc-testcases/src/tests/givenDRI.scala
@@ -4,11 +4,11 @@ trait A[T]
 trait B[T]
 trait C
 
-given A[Int]
+given A[Int] with {}
 
-given A[String]
+given A[String] with {}
 
-given A[Seq[String]]
+given A[Seq[String]] with {}
 
 given [T: A]: A[Option[T]] with {}
 
@@ -16,7 +16,7 @@ given [T: B]: A[T] with {}
 
 given [C]: A[C] with {}
 
-given A[C]
+given A[C] with {}
 
 given [S <: C]: A[S] with {}
 
diff --git a/scala3doc-testcases/src/tests/inheritedMembers1.scala b/scala3doc-testcases/src/tests/inheritedMembers1.scala
index 9f8f6254f2cd..6a86c523bd19 100644
--- a/scala3doc-testcases/src/tests/inheritedMembers1.scala
+++ b/scala3doc-testcases/src/tests/inheritedMembers1.scala
@@ -10,7 +10,7 @@ class A
       = ???
     object X
     trait Z
-    given B
+    given B with {}
     type I = Int
     /*<-*/extension (a: A) /*->*/def extension: String
       = ???
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..790a2a37e727 100644
--- a/tests/neg-macros/i7919.scala
+++ b/tests/neg-macros/i7919.scala
@@ -3,16 +3,16 @@ 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" }
   }
 
-  given Expr[Int] // error
+  given Expr[Int] with {} // error
   new Expr[Int] // error
   class Expr2 extends Expr[Int] // error
 
-  given Type[Int] // error
+  given Type[Int] with {} // error
   new Type[Int] // error
   class Type2 extends Type[Int] // error
 
diff --git a/tests/neg/empty-given.scala b/tests/neg/empty-given.scala
index cf7566724cc2..10daf5ac009a 100644
--- a/tests/neg/empty-given.scala
+++ b/tests/neg/empty-given.scala
@@ -1,3 +1,3 @@
-given {
+given {    // error
   def foo = 1  // error
-}
\ No newline at end of file
+} // error
\ No newline at end of file
diff --git a/tests/neg/i5978.scala b/tests/neg/i5978.scala
index fddc83df44d4..1c81160dba0a 100644
--- a/tests/neg/i5978.scala
+++ b/tests/neg/i5978.scala
@@ -8,7 +8,7 @@ object TextParser {
   given TP: TokenParser[Char, Position[CharSequence]] with {}
 
   given FromCharToken(using T: TokenParser[Char, Position[CharSequence]])
-    as Conversion[Char, Position[CharSequence]] = ???
+    : Conversion[Char, Position[CharSequence]] = ???
 }
 
 object Testcase {
diff --git a/tests/neg/transparent.scala b/tests/neg/transparent.scala
index fcd167799ba2..f2aae0348b45 100644
--- a/tests/neg/transparent.scala
+++ b/tests/neg/transparent.scala
@@ -5,5 +5,5 @@ transparent class c // error
 transparent object y // error
 transparent trait t // ok
 transparent type T = c  // error
-transparent given c // error
+transparent given c with {} // error
 
diff --git a/tests/pos-custom-args/erased/i7868.scala b/tests/pos-custom-args/erased/i7868.scala
index 710598718acd..2753cf444af4 100644
--- a/tests/pos-custom-args/erased/i7868.scala
+++ b/tests/pos-custom-args/erased/i7868.scala
@@ -18,7 +18,7 @@ object Coproduct {
 
     given atTail[Head, Tail, Value, NextIndex <: Int]
           (using atNext: At[Tail, Value, NextIndex])
-          as At[Head +: Tail, Value, S[NextIndex]]:
+      : At[Head +: Tail, Value, S[NextIndex]] with
       val cast: Value <:< Head +: Tail = atNext.cast
 
     given [A](using A): (() => A) = { () => summon[A]}
diff --git a/tests/pos/i5978.scala b/tests/pos/i5978.scala
index 74e5b5f632b4..57dda97267a9 100644
--- a/tests/pos/i5978.scala
+++ b/tests/pos/i5978.scala
@@ -16,7 +16,7 @@ package p1 {
 
       // skipping newlines is OK here
 
-      as Conversion[Char, Position[CharSequence]] = ???
+      : Conversion[Char, Position[CharSequence]] = ???
   }
 
   object Testcase {
diff --git a/tests/pos/i6716.scala b/tests/pos/i6716.scala
index 75919e06e3ef..446cd49c9214 100644
--- a/tests/pos/i6716.scala
+++ b/tests/pos/i6716.scala
@@ -1,7 +1,7 @@
 trait Monad[T]
 class Foo
 object Foo {
-  given Monad[Foo]
+  given Monad[Foo] with {}
 }
 
 opaque type Bar = Foo
diff --git a/tests/pos/i6864.scala b/tests/pos/i6864.scala
index 9d5f6b1c1c42..af0f3d22ba50 100644
--- a/tests/pos/i6864.scala
+++ b/tests/pos/i6864.scala
@@ -1,17 +1,17 @@
 class A
 class B
 
-given A
-given B
+given A with {}
+given B with {}
 
 trait Foo
 trait Bar
 
-given Foo
-given Bar
+given Foo with {}
+given Bar with {}
 
 trait C
 trait Baz[A]
 
-given C
+given C with {}
 given [A]: Baz[A] with {}
\ No newline at end of file
diff --git a/tests/pos/i8397.scala b/tests/pos/i8397.scala
index b04c70153b40..d0b97f84129d 100644
--- a/tests/pos/i8397.scala
+++ b/tests/pos/i8397.scala
@@ -18,5 +18,5 @@ given [A]: Lub[A] with
 given [Left, Right](
     using lubLeft: Lub[Right], lubRight: Lub[Right])(
     using lub2: Lub2[lubLeft.Output, lubRight.Output])
-as Lub[Left | Right]:
+  : Lub[Left | Right] with
   type Output = lub2.Output
diff --git a/tests/pos/i8623.scala b/tests/pos/i8623.scala
index b3f4ad8c4f91..e0df48811e1c 100644
--- a/tests/pos/i8623.scala
+++ b/tests/pos/i8623.scala
@@ -11,7 +11,7 @@ def test1 =
   unseal.pos
 
 def test2 =
-  given QC
+  given QC with {}
   def unseal(using qctx: QC): qctx.tasty.Tree = ???
   unseal.pos
 
diff --git a/tests/pos/the-given.scala b/tests/pos/the-given.scala
index 90ff49f6fe75..97c0e5099215 100644
--- a/tests/pos/the-given.scala
+++ b/tests/pos/the-given.scala
@@ -1,7 +1,7 @@
 object Test {
 
   class Encoder { def apply(x: Int): Int = x }
-  given Encoder
+  given Encoder with {}
 
   summon[Encoder](2)
 
diff --git a/tests/run/given-eta.scala b/tests/run/given-eta.scala
index a01f1c441018..1eaf6fd16c49 100644
--- a/tests/run/given-eta.scala
+++ b/tests/run/given-eta.scala
@@ -8,7 +8,7 @@ def f(x: Int)(using c: C) (y: Int) = x + c.x + y
 def g(x: Int)(using d: D) (y: d.T): d.T = d.trans(y)
 
 @main def Test =
-  given C(1)
+  given C(1) with {}
   val x = f
   assert(x(2)(3) == 6)
 
diff --git a/tests/run/implicit-alias.scala b/tests/run/implicit-alias.scala
index ee6ca48da1be..1a30a3d22915 100644
--- a/tests/run/implicit-alias.scala
+++ b/tests/run/implicit-alias.scala
@@ -6,7 +6,7 @@ object Test extends App {
 
   class TC1
 
-  given TC1
+  given TC1 with {}
 
   class TV(val tc: TC) extends AnyVal
 
diff --git a/tests/run/implicit-specifity.scala b/tests/run/implicit-specifity.scala
index 7b57446c2aeb..c92ee5f9acef 100644
--- a/tests/run/implicit-specifity.scala
+++ b/tests/run/implicit-specifity.scala
@@ -20,7 +20,7 @@ object Generic2 {
 
 class SubGen extends Generic
 object SubGen {
-  given SubGen
+  given SubGen with {}
 }
 object Contextual {
   trait Context
diff --git a/tests/run/implied-specifity-2.scala b/tests/run/implied-specifity-2.scala
index d107081e78b3..a787531c1089 100644
--- a/tests/run/implied-specifity-2.scala
+++ b/tests/run/implied-specifity-2.scala
@@ -31,7 +31,7 @@ object Baz {
 
 class Arg
 
-given Arg
+given Arg with {}
 
 class Bam(val str: String)
 
@@ -62,7 +62,7 @@ object Test extends App {
   assert(summon[Bam2].str == "hi")
   assert(summon[Red].str == "reduced")
 
-  { given Arg2
+  { given Arg2 with {}
     assert(summon[Red].str == "normal")
   }
 }
\ No newline at end of file
diff --git a/tests/run/inline-override-num.scala b/tests/run/inline-override-num.scala
index 9770cba7f2da..06f0ae91c0f8 100644
--- a/tests/run/inline-override-num.scala
+++ b/tests/run/inline-override-num.scala
@@ -6,7 +6,7 @@ object Num {
   class IntNum extends Num[Int] {
     inline def plus(x: Int, y: Int): Int = x + y
   }
-  given IntNum
+  given IntNum with {}
 
   extension [T](inline x: T)(using inline num: Num[T]) {
     inline def +(inline y: T): T = num.plus(x, y)