diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index c7bf0ace48c6..febdd24552fc 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -124,11 +124,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type PackageClause = tpd.PackageDef
 
-    object PackageClauseTypeTest extends TypeTest[Tree, PackageClause]:
+    object PackageClauseTypeTestImpl extends TypeTest[Tree, PackageClause]:
       def unapply(x: Tree): Option[PackageClause & x.type] = x match
         case x: (tpd.PackageDef & x.type) => Some(x)
         case _ => None
-    end PackageClauseTypeTest
+    end PackageClauseTypeTestImpl
 
     object PackageClause extends PackageClauseModule:
       def apply(pid: Ref, stats: List[Tree]): PackageClause =
@@ -148,11 +148,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Import = tpd.Import
 
-    object ImportTypeTest extends TypeTest[Tree, Import]:
+    object ImportTypeTestImpl extends TypeTest[Tree, Import]:
       def unapply(x: Tree): Option[Import & x.type] = x match
         case tree: (tpd.Import & x.type) => Some(tree)
         case _ => None
-    end ImportTypeTest
+    end ImportTypeTestImpl
 
     object Import extends ImportModule:
       def apply(expr: Term, selectors: List[ImportSelector]): Import =
@@ -172,21 +172,21 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Statement = tpd.Tree
 
-    object StatementTypeTest extends TypeTest[Tree, Statement]:
+    object StatementTypeTestImpl extends TypeTest[Tree, Statement]:
       def unapply(x: Tree): Option[Statement & x.type] = x match
         case _: tpd.PatternTree => None
         case _ =>
           if x.isTerm then TermTypeTest.unapply(x)
           else DefinitionTypeTest.unapply(x)
-    end StatementTypeTest
+    end StatementTypeTestImpl
 
     type Definition = tpd.MemberDef
 
-    object DefinitionTypeTest extends TypeTest[Tree, Definition]:
+    object DefinitionTypeTestImpl extends TypeTest[Tree, Definition]:
       def unapply(x: Tree): Option[Definition & x.type] = x match
         case x: (tpd.MemberDef & x.type) => Some(x)
         case _ => None
-    end DefinitionTypeTest
+    end DefinitionTypeTestImpl
 
     object Definition extends DefinitionModule
 
@@ -199,11 +199,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ClassDef = tpd.TypeDef
 
-    object ClassDefTypeTest extends TypeTest[Tree, ClassDef]:
+    object ClassDefTypeTestImpl extends TypeTest[Tree, ClassDef]:
       def unapply(x: Tree): Option[ClassDef & x.type] = x match
         case x: (tpd.TypeDef & x.type) if x.isClassDef => Some(x)
         case _ => None
-    end ClassDefTypeTest
+    end ClassDefTypeTestImpl
 
     object ClassDef extends ClassDefModule:
       def copy(original: Tree)(name: String, constr: DefDef, parents: List[Tree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement]): ClassDef = {
@@ -232,11 +232,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type DefDef = tpd.DefDef
 
-    object DefDefTypeTest extends TypeTest[Tree, DefDef]:
+    object DefDefTypeTestImpl extends TypeTest[Tree, DefDef]:
       def unapply(x: Tree): Option[DefDef & x.type] = x match
         case x: (tpd.DefDef & x.type) => Some(x)
         case _ => None
-    end DefDefTypeTest
+    end DefDefTypeTestImpl
 
     object DefDef extends DefDefModule:
       def apply(symbol: Symbol, rhsFn: List[TypeRepr] => List[List[Term]] => Option[Term]): DefDef =
@@ -258,11 +258,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ValDef = tpd.ValDef
 
-    object ValDefTypeTest extends TypeTest[Tree, ValDef]:
+    object ValDefTypeTestImpl extends TypeTest[Tree, ValDef]:
       def unapply(x: Tree): Option[ValDef & x.type] = x match
         case x: (tpd.ValDef & x.type) => Some(x)
         case _ => None
-    end ValDefTypeTest
+    end ValDefTypeTestImpl
 
     object ValDef extends ValDefModule:
       def apply(symbol: Symbol, rhs: Option[Term]): ValDef =
@@ -293,11 +293,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeDef = tpd.TypeDef
 
-    object TypeDefTypeTest extends TypeTest[Tree, TypeDef]:
+    object TypeDefTypeTestImpl extends TypeTest[Tree, TypeDef]:
       def unapply(x: Tree): Option[TypeDef & x.type] = x match
         case x: (tpd.TypeDef & x.type) if !x.isClassDef => Some(x)
         case _ => None
-    end TypeDefTypeTest
+    end TypeDefTypeTestImpl
 
     object TypeDef extends TypeDefModule:
       def apply(symbol: Symbol): TypeDef =
@@ -316,7 +316,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Term = tpd.Tree
 
-    object TermTypeTest extends TypeTest[Tree, Term]:
+    object TermTypeTestImpl extends TypeTest[Tree, Term]:
       def unapply(x: Tree): Option[Term & x.type] = x match
         case _ if UnapplyTypeTest.unapply(x).isDefined => None
         case _: tpd.PatternTree => None
@@ -325,7 +325,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         case x: (tpd.Inlined & x.type) => Some(x)
         case x: (tpd.NamedArg & x.type) => Some(x)
         case _ => None
-    end TermTypeTest
+    end TermTypeTestImpl
 
     object Term extends TermModule:
       def of(expr: Expr[Any]): Term =
@@ -395,11 +395,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Ref = tpd.RefTree
 
-    object RefTypeTest extends TypeTest[Tree, Ref]:
+    object RefTypeTestImpl extends TypeTest[Tree, Ref]:
       def unapply(x: Tree): Option[Ref & x.type] = x match
         case x: (tpd.RefTree & x.type) if x.isTerm => Some(x)
         case _ => None
-    end RefTypeTest
+    end RefTypeTestImpl
 
     object Ref extends RefModule:
       def term(tp: TermRef): Ref =
@@ -411,11 +411,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Ident = tpd.Ident
 
-    object IdentTypeTest extends TypeTest[Tree, Ident]:
+    object IdentTypeTestImpl extends TypeTest[Tree, Ident]:
       def unapply(x: Tree): Option[Ident & x.type] = x match
         case x: (tpd.Ident & x.type) if x.isTerm => Some(x)
         case _ => None
-    end IdentTypeTest
+    end IdentTypeTestImpl
 
     object Ident extends IdentModule:
       def apply(tmref: TermRef): Term =
@@ -434,11 +434,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Select = tpd.Select
 
-    object SelectTypeTest extends TypeTest[Tree, Select]:
+    object SelectTypeTestImpl extends TypeTest[Tree, Select]:
       def unapply(x: Tree): Option[Select & x.type] = x match
         case x: (tpd.Select & x.type) if x.isTerm => Some(x)
         case _ => None
-    end SelectTypeTest
+    end SelectTypeTestImpl
 
     object Select extends SelectModule:
       def apply(qualifier: Term, symbol: Symbol): Select =
@@ -470,11 +470,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Literal = tpd.Literal
 
-    object LiteralTypeTest extends TypeTest[Tree, Literal]:
+    object LiteralTypeTestImpl extends TypeTest[Tree, Literal]:
       def unapply(x: Tree): Option[Literal & x.type] = x match
         case x: (tpd.Literal & x.type) => Some(x)
         case _ => None
-    end LiteralTypeTest
+    end LiteralTypeTestImpl
 
     object Literal extends LiteralModule:
       def apply(constant: Constant): Literal =
@@ -493,11 +493,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type This = tpd.This
 
-    object ThisTypeTest extends TypeTest[Tree, This]:
+    object ThisTypeTestImpl extends TypeTest[Tree, This]:
       def unapply(x: Tree): Option[This & x.type] = x match
         case x: (tpd.This & x.type) => Some(x)
         case _ => None
-    end ThisTypeTest
+    end ThisTypeTestImpl
 
     object This extends ThisModule:
       def apply(cls: Symbol): This =
@@ -516,11 +516,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type New = tpd.New
 
-    object NewTypeTest extends TypeTest[Tree, New]:
+    object NewTypeTestImpl extends TypeTest[Tree, New]:
       def unapply(x: Tree): Option[New & x.type] = x match
         case x: (tpd.New & x.type) => Some(x)
         case _ => None
-    end NewTypeTest
+    end NewTypeTestImpl
 
     object New extends NewModule:
       def apply(tpt: TypeTree): New =
@@ -538,11 +538,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type NamedArg = tpd.NamedArg
 
-    object NamedArgTypeTest extends TypeTest[Tree, NamedArg]:
+    object NamedArgTypeTestImpl extends TypeTest[Tree, NamedArg]:
       def unapply(x: Tree): Option[NamedArg & x.type] = x match
         case x: (tpd.NamedArg & x.type) if x.name.isInstanceOf[dotc.core.Names.TermName] => Some(x) // TODO: Now, the name should alwas be a term name
         case _ => None
-    end NamedArgTypeTest
+    end NamedArgTypeTestImpl
 
     object NamedArg extends NamedArgModule:
       def apply(name: String, arg: Term): NamedArg =
@@ -562,11 +562,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Apply = tpd.Apply
 
-    object ApplyTypeTest extends TypeTest[Tree, Apply]:
+    object ApplyTypeTestImpl extends TypeTest[Tree, Apply]:
       def unapply(x: Tree): Option[Apply & x.type] = x match
         case x: (tpd.Apply & x.type) => Some(x)
         case _ => None
-    end ApplyTypeTest
+    end ApplyTypeTestImpl
 
     object Apply extends ApplyModule:
       def apply(fun: Term, args: List[Term]): Apply =
@@ -586,11 +586,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeApply = tpd.TypeApply
 
-    object TypeApplyTypeTest extends TypeTest[Tree, TypeApply]:
+    object TypeApplyTypeTestImpl extends TypeTest[Tree, TypeApply]:
       def unapply(x: Tree): Option[TypeApply & x.type] = x match
         case x: (tpd.TypeApply & x.type) => Some(x)
         case _ => None
-    end TypeApplyTypeTest
+    end TypeApplyTypeTestImpl
 
     object TypeApply extends TypeApplyModule:
       def apply(fun: Term, args: List[TypeTree]): TypeApply =
@@ -610,11 +610,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Super = tpd.Super
 
-    object SuperTypeTest extends TypeTest[Tree, Super]:
+    object SuperTypeTestImpl extends TypeTest[Tree, Super]:
       def unapply(x: Tree): Option[Super & x.type] = x match
         case x: (tpd.Super & x.type) => Some(x)
         case _ => None
-    end SuperTypeTest
+    end SuperTypeTestImpl
 
     object Super extends SuperModule:
       def apply(qual: Term, mix: Option[String]): Super =
@@ -635,11 +635,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Typed = tpd.Typed
 
-    object TypedTypeTest extends TypeTest[Tree, Typed]:
+    object TypedTypeTestImpl extends TypeTest[Tree, Typed]:
       def unapply(x: Tree): Option[Typed & x.type] = x match
         case x: (tpd.Typed & x.type) => Some(x)
         case _ => None
-    end TypedTypeTest
+    end TypedTypeTestImpl
 
     object Typed extends TypedModule:
       def apply(expr: Term, tpt: TypeTree): Typed =
@@ -659,11 +659,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Assign = tpd.Assign
 
-    object AssignTypeTest extends TypeTest[Tree, Assign]:
+    object AssignTypeTestImpl extends TypeTest[Tree, Assign]:
       def unapply(x: Tree): Option[Assign & x.type] = x match
         case x: (tpd.Assign & x.type) => Some(x)
         case _ => None
-    end AssignTypeTest
+    end AssignTypeTestImpl
 
     object Assign extends AssignModule:
       def apply(lhs: Term, rhs: Term): Assign =
@@ -683,11 +683,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Block = tpd.Block
 
-    val BlockTypeTest: TypeTest[Tree, Block] = new {
+    object BlockTypeTestImpl extends TypeTest[Tree, Block]:
       def unapply(x: Tree): Option[Block & x.type] = x match
         case x: (tpd.Block & x.type) => Some(x)
         case _ => None
-    }
+    end BlockTypeTestImpl
 
     object Block extends BlockModule:
       def apply(stats: List[Statement], expr: Term): Block =
@@ -707,11 +707,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Closure = tpd.Closure
 
-    object ClosureTypeTest extends TypeTest[Tree, Closure]:
+    object ClosureTypeTestImpl extends TypeTest[Tree, Closure]:
       def unapply(x: Tree): Option[Closure & x.type] = x match
         case x: (tpd.Closure & x.type) => Some(x)
         case _ => None
-    end ClosureTypeTest
+    end ClosureTypeTestImpl
 
     object Closure extends ClosureModule:
       def apply(meth: Term, tpe: Option[TypeRepr]): Closure =
@@ -744,11 +744,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type If = tpd.If
 
-    object IfTypeTest extends TypeTest[Tree, If]:
+    object IfTypeTestImpl extends TypeTest[Tree, If]:
       def unapply(x: Tree): Option[If & x.type] = x match
         case x: (tpd.If & x.type) => Some(x)
         case _ => None
-    end IfTypeTest
+    end IfTypeTestImpl
 
     object If extends IfModule:
       def apply(cond: Term, thenp: Term, elsep: Term): If =
@@ -769,11 +769,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Match = tpd.Match
 
-    object MatchTypeTest extends TypeTest[Tree, Match]:
+    object MatchTypeTestImpl extends TypeTest[Tree, Match]:
       def unapply(x: Tree): Option[Match & x.type] = x match
         case x: (tpd.Match & x.type) if !x.selector.isEmpty => Some(x)
         case _ => None
-    end MatchTypeTest
+    end MatchTypeTestImpl
 
     object Match extends MatchModule:
       def apply(selector: Term, cases: List[CaseDef]): Match =
@@ -795,11 +795,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type SummonFrom = tpd.Match
 
-    object SummonFromTypeTest extends TypeTest[Tree, SummonFrom]:
+    object SummonFromTypeTestImpl extends TypeTest[Tree, SummonFrom]:
       def unapply(x: Tree): Option[SummonFrom & x.type] = x match
         case x: (tpd.Match & x.type) if x.selector.isEmpty => Some(x)
         case _ => None
-    end SummonFromTypeTest
+    end SummonFromTypeTestImpl
 
     object SummonFrom extends SummonFromModule:
       def apply(cases: List[CaseDef]): SummonFrom =
@@ -818,11 +818,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Try = tpd.Try
 
-    object TryTypeTest extends TypeTest[Tree, Try]:
+    object TryTypeTestImpl extends TypeTest[Tree, Try]:
       def unapply(x: Tree): Option[Try & x.type] = x match
         case x: (tpd.Try & x.type) => Some(x)
         case _ => None
-    end TryTypeTest
+    end TryTypeTestImpl
 
     object Try extends TryModule:
       def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term]): Try =
@@ -843,11 +843,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Return = tpd.Return
 
-    object ReturnTypeTest extends TypeTest[Tree, Return]:
+    object ReturnTypeTestImpl extends TypeTest[Tree, Return]:
       def unapply(x: Tree): Option[Return & x.type] = x match
         case x: (tpd.Return & x.type) => Some(x)
         case _ => None
-    end ReturnTypeTest
+    end ReturnTypeTestImpl
 
     object Return extends ReturnModule:
       def apply(expr: Term, from: Symbol): Return =
@@ -867,11 +867,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Repeated = tpd.SeqLiteral
 
-    object RepeatedTypeTest extends TypeTest[Tree, Repeated]:
+    object RepeatedTypeTestImpl extends TypeTest[Tree, Repeated]:
       def unapply(x: Tree): Option[Repeated & x.type] = x match
         case x: (tpd.SeqLiteral & x.type) => Some(x)
         case _ => None
-    end RepeatedTypeTest
+    end RepeatedTypeTestImpl
 
     object Repeated extends RepeatedModule:
       def apply(elems: List[Term], elemtpt: TypeTree): Repeated =
@@ -891,11 +891,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Inlined = tpd.Inlined
 
-    object InlinedTypeTest extends TypeTest[Tree, Inlined]:
+    object InlinedTypeTestImpl extends TypeTest[Tree, Inlined]:
       def unapply(x: Tree): Option[Inlined & x.type] = x match
         case x: (tpd.Inlined & x.type) => Some(x)
         case _ => None
-    end InlinedTypeTest
+    end InlinedTypeTestImpl
 
     object Inlined extends InlinedModule:
       def apply(call: Option[Tree], bindings: List[Definition], expansion: Term): Inlined =
@@ -916,14 +916,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type SelectOuter = tpd.Select
 
-    object SelectOuterTypeTest extends TypeTest[Tree, SelectOuter]:
+    object SelectOuterTypeTestImpl extends TypeTest[Tree, SelectOuter]:
       def unapply(x: Tree): Option[SelectOuter & x.type] = x match
         case x: (tpd.Select & x.type) =>
           x.name match
             case NameKinds.OuterSelectName(_, _) => Some(x)
             case _ => None
         case _ => None
-    end SelectOuterTypeTest
+    end SelectOuterTypeTestImpl
 
     object SelectOuter extends SelectOuterModule:
       def apply(qualifier: Term, name: String, levels: Int): SelectOuter =
@@ -946,11 +946,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type While = tpd.WhileDo
 
-    object WhileTypeTest extends TypeTest[Tree, While]:
+    object WhileTypeTestImpl extends TypeTest[Tree, While]:
       def unapply(x: Tree): Option[While & x.type] = x match
         case x: (tpd.WhileDo & x.type) => Some(x)
         case _ => None
-    end WhileTypeTest
+    end WhileTypeTestImpl
 
     object While extends WhileModule:
       def apply(cond: Term, body: Term): While =
@@ -970,12 +970,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeTree = tpd.Tree
 
-    object TypeTreeTypeTest extends TypeTest[Tree, TypeTree]:
+    object TypeTreeTypeTestImpl extends TypeTest[Tree, TypeTree]:
       def unapply(x: Tree): Option[TypeTree & x.type] = x match
         case x: (tpd.TypeBoundsTree & x.type) => None
         case x: (tpd.Tree & x.type) if x.isType => Some(x)
         case _ => None
-    end TypeTreeTypeTest
+    end TypeTreeTypeTestImpl
 
     object TypeTree extends TypeTreeModule:
       def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree =
@@ -990,11 +990,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Inferred = tpd.TypeTree
 
-    object InferredTypeTest extends TypeTest[Tree, Inferred]:
+    object InferredTypeTestImpl extends TypeTest[Tree, Inferred]:
       def unapply(x: Tree): Option[Inferred & x.type] = x match
         case tpt: (tpd.TypeTree & x.type) if !tpt.tpe.isInstanceOf[Types.TypeBounds] => Some(tpt)
         case _ => None
-    end InferredTypeTest
+    end InferredTypeTestImpl
 
     object Inferred extends InferredModule:
       def apply(tpe: TypeRepr): Inferred =
@@ -1004,11 +1004,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeIdent = tpd.Ident
 
-    object TypeIdentTypeTest extends TypeTest[Tree, TypeIdent]:
+    object TypeIdentTypeTestImpl extends TypeTest[Tree, TypeIdent]:
       def unapply(x: Tree): Option[TypeIdent & x.type] = x match
         case tpt: (tpd.Ident & x.type) if tpt.isType => Some(tpt)
         case _ => None
-    end TypeIdentTypeTest
+    end TypeIdentTypeTestImpl
 
     object TypeIdent extends TypeIdentModule:
       def apply(sym: Symbol): TypeTree =
@@ -1028,11 +1028,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeSelect = tpd.Select
 
-    object TypeSelectTypeTest extends TypeTest[Tree, TypeSelect]:
+    object TypeSelectTypeTestImpl extends TypeTest[Tree, TypeSelect]:
       def unapply(x: Tree): Option[TypeSelect & x.type] = x match
         case tpt: (tpd.Select & x.type) if tpt.isType && tpt.qualifier.isTerm  => Some(tpt)
         case _ => None
-    end TypeSelectTypeTest
+    end TypeSelectTypeTestImpl
 
     object TypeSelect extends TypeSelectModule:
       def apply(qualifier: Term, name: String): TypeSelect =
@@ -1052,11 +1052,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeProjection = tpd.Select
 
-    object TypeProjectionTypeTest extends TypeTest[Tree, TypeProjection]:
+    object TypeProjectionTypeTestImpl extends TypeTest[Tree, TypeProjection]:
       def unapply(x: Tree): Option[TypeProjection & x.type] = x match
         case tpt: (tpd.Select & x.type) if tpt.isType && tpt.qualifier.isType => Some(tpt)
         case _ => None
-    end TypeProjectionTypeTest
+    end TypeProjectionTypeTestImpl
 
     object TypeProjection extends TypeProjectionModule:
       def copy(original: Tree)(qualifier: TypeTree, name: String): TypeProjection =
@@ -1074,11 +1074,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Singleton = tpd.SingletonTypeTree
 
-    object SingletonTypeTest extends TypeTest[Tree, Singleton]:
+    object SingletonTypeTestImpl extends TypeTest[Tree, Singleton]:
       def unapply(x: Tree): Option[Singleton & x.type] = x match
         case tpt: (tpd.SingletonTypeTree & x.type) => Some(tpt)
         case _ => None
-    end SingletonTypeTest
+    end SingletonTypeTestImpl
 
     object Singleton extends SingletonModule:
       def apply(ref: Term): Singleton =
@@ -1097,11 +1097,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Refined = tpd.RefinedTypeTree
 
-    object RefinedTypeTest extends TypeTest[Tree, Refined]:
+    object RefinedTypeTestImpl extends TypeTest[Tree, Refined]:
       def unapply(x: Tree): Option[Refined & x.type] = x match
         case tpt: (tpd.RefinedTypeTree & x.type) => Some(tpt)
         case _ => None
-    end RefinedTypeTest
+    end RefinedTypeTestImpl
 
     object Refined extends RefinedModule:
       def copy(original: Tree)(tpt: TypeTree, refinements: List[Definition]): Refined =
@@ -1119,11 +1119,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Applied = tpd.AppliedTypeTree
 
-    object AppliedTypeTest extends TypeTest[Tree, Applied]:
+    object AppliedTypeTestImpl extends TypeTest[Tree, Applied]:
       def unapply(x: Tree): Option[Applied & x.type] = x match
         case tpt: (tpd.AppliedTypeTree & x.type) => Some(tpt)
         case _ => None
-    end AppliedTypeTest
+    end AppliedTypeTestImpl
 
     object Applied extends AppliedModule:
       def apply(tpt: TypeTree, args: List[Tree]): Applied =
@@ -1143,11 +1143,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Annotated = tpd.Annotated
 
-    object AnnotatedTypeTest extends TypeTest[Tree, Annotated]:
+    object AnnotatedTypeTestImpl extends TypeTest[Tree, Annotated]:
       def unapply(x: Tree): Option[Annotated & x.type] = x match
         case tpt: (tpd.Annotated & x.type) => Some(tpt)
         case _ => None
-    end AnnotatedTypeTest
+    end AnnotatedTypeTestImpl
 
     object Annotated extends AnnotatedModule:
       def apply(arg: TypeTree, annotation: Term): Annotated =
@@ -1167,11 +1167,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type MatchTypeTree = tpd.MatchTypeTree
 
-    object MatchTypeTreeTypeTest extends TypeTest[Tree, MatchTypeTree]:
+    object MatchTypeTreeTypeTestImpl extends TypeTest[Tree, MatchTypeTree]:
       def unapply(x: Tree): Option[MatchTypeTree & x.type] = x match
         case tpt: (tpd.MatchTypeTree & x.type) => Some(tpt)
         case _ => None
-    end MatchTypeTreeTypeTest
+    end MatchTypeTreeTypeTestImpl
 
     object MatchTypeTree extends MatchTypeTreeModule:
       def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef]): MatchTypeTree =
@@ -1192,11 +1192,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ByName = tpd.ByNameTypeTree
 
-    object ByNameTypeTest extends TypeTest[Tree, ByName]:
+    object ByNameTypeTestImpl extends TypeTest[Tree, ByName]:
       def unapply(x: Tree): Option[ByName & x.type] = x match
         case tpt: (tpd.ByNameTypeTree & x.type) => Some(tpt)
         case _ => None
-    end ByNameTypeTest
+    end ByNameTypeTestImpl
 
     object ByName extends ByNameModule:
       def apply(result: TypeTree): ByName =
@@ -1215,11 +1215,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type LambdaTypeTree = tpd.LambdaTypeTree
 
-    object LambdaTypeTreeTypeTest extends TypeTest[Tree, LambdaTypeTree]:
+    object LambdaTypeTreeTypeTestImpl extends TypeTest[Tree, LambdaTypeTree]:
       def unapply(x: Tree): Option[LambdaTypeTree & x.type] = x match
         case tpt: (tpd.LambdaTypeTree & x.type) => Some(tpt)
         case _ => None
-    end LambdaTypeTreeTypeTest
+    end LambdaTypeTreeTypeTestImpl
 
     object LambdaTypeTree extends LambdaTypeTreeModule:
       def apply(tparams: List[TypeDef], body: Tree): LambdaTypeTree =
@@ -1239,11 +1239,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeBind = tpd.Bind
 
-    object TypeBindTypeTest extends TypeTest[Tree, TypeBind]:
+    object TypeBindTypeTestImpl extends TypeTest[Tree, TypeBind]:
       def unapply(x: Tree): Option[TypeBind & x.type] = x match
         case tpt: (tpd.Bind & x.type) if tpt.name.isTypeName => Some(tpt)
         case _ => None
-    end TypeBindTypeTest
+    end TypeBindTypeTestImpl
 
     object TypeBind extends TypeBindModule:
       def copy(original: Tree)(name: String, tpt: Tree): TypeBind =
@@ -1261,11 +1261,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeBlock = tpd.Block
 
-    object TypeBlockTypeTest extends TypeTest[Tree, TypeBlock]:
+    object TypeBlockTypeTestImpl extends TypeTest[Tree, TypeBlock]:
       def unapply(x: Tree): Option[TypeBlock & x.type] = x match
         case tpt: (tpd.Block & x.type) => Some(tpt)
         case _ => None
-    end TypeBlockTypeTest
+    end TypeBlockTypeTestImpl
 
     object TypeBlock extends TypeBlockModule:
       def apply(aliases: List[TypeDef], tpt: TypeTree): TypeBlock =
@@ -1285,7 +1285,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeBoundsTree = tpd.TypeBoundsTree | tpd.TypeTree
 
-    object TypeBoundsTreeTypeTest extends TypeTest[Tree, TypeBoundsTree]:
+    object TypeBoundsTreeTypeTestImpl extends TypeTest[Tree, TypeBoundsTree]:
       def unapply(x: Tree): Option[TypeBoundsTree & x.type] = x match
         case x: (tpd.TypeBoundsTree & x.type) => Some(x)
         case x: (tpd.TypeTree & x.type) =>
@@ -1293,7 +1293,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case tpe: Types.TypeBounds => Some(x)
             case _ => None
         case _ => None
-    end TypeBoundsTreeTypeTest
+    end TypeBoundsTreeTypeTestImpl
 
     object TypeBoundsTree extends TypeBoundsTreeModule:
       def apply(low: TypeTree, hi: TypeTree): TypeBoundsTree =
@@ -1318,11 +1318,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type WildcardTypeTree = tpd.Ident
 
-    object WildcardTypeTreeTypeTest extends TypeTest[Tree, WildcardTypeTree]:
+    object WildcardTypeTreeTypeTestImpl extends TypeTest[Tree, WildcardTypeTree]:
       def unapply(x: Tree): Option[WildcardTypeTree & x.type] = x match
         case x: (tpd.Ident & x.type) if x.name == nme.WILDCARD => Some(x)
         case _ => None
-    end WildcardTypeTreeTypeTest
+    end WildcardTypeTreeTypeTestImpl
 
     object WildcardTypeTree extends WildcardTypeTreeModule:
       def apply(tpe: TypeRepr): WildcardTypeTree = withDefaultPos(tpd.Underscore(tpe))
@@ -1337,11 +1337,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type CaseDef = tpd.CaseDef
 
-    object CaseDefTypeTest extends TypeTest[Tree, CaseDef]:
+    object CaseDefTypeTestImpl extends TypeTest[Tree, CaseDef]:
       def unapply(x: Tree): Option[CaseDef & x.type] = x match
         case tree: (tpd.CaseDef & x.type) if tree.body.isTerm => Some(tree)
         case _ => None
-    end CaseDefTypeTest
+    end CaseDefTypeTestImpl
 
     object CaseDef extends CaseDefModule:
       def apply(pattern: Tree, guard: Option[Term], rhs: Term): CaseDef =
@@ -1362,11 +1362,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeCaseDef = tpd.CaseDef
 
-    object TypeCaseDefTypeTest extends TypeTest[Tree, TypeCaseDef]:
+    object TypeCaseDefTypeTestImpl extends TypeTest[Tree, TypeCaseDef]:
       def unapply(x: Tree): Option[TypeCaseDef & x.type] = x match
         case tree: (tpd.CaseDef & x.type) if tree.body.isType => Some(tree)
         case _ => None
-    end TypeCaseDefTypeTest
+    end TypeCaseDefTypeTestImpl
 
     object TypeCaseDef extends TypeCaseDefModule:
       def apply(pattern: TypeTree, rhs: TypeTree): TypeCaseDef =
@@ -1386,11 +1386,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Bind = tpd.Bind
 
-    object BindTypeTest extends TypeTest[Tree, Bind]:
+    object BindTypeTestImpl extends TypeTest[Tree, Bind]:
       def unapply(x: Tree): Option[Bind & x.type] = x match
         case x: (tpd.Bind & x.type) if x.name.isTermName => Some(x)
         case _ => None
-    end BindTypeTest
+    end BindTypeTestImpl
 
     object Bind extends BindModule:
       def apply(sym: Symbol, pattern: Tree): Bind =
@@ -1410,13 +1410,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Unapply = tpd.UnApply | tpd.Typed // tpd.Typed containing a tpd.UnApply as expression
 
-    object UnapplyTypeTest extends TypeTest[Tree, Unapply]:
+    object UnapplyTypeTestImpl extends TypeTest[Tree, Unapply]:
       def unapply(x: Tree): Option[Unapply & x.type] =
         x match // keep in sync with UnapplyMethodsImpl.selfUnApply
           case x: (tpd.UnApply & x.type) => Some(x)
           case x: (tpd.Typed & x.type) if x.expr.isInstanceOf[tpd.UnApply] => Some(x)
           case _ => None
-    end UnapplyTypeTest
+    end UnapplyTypeTestImpl
 
     object Unapply extends UnapplyModule:
       def copy(original: Tree)(fun: Term, implicits: List[Term], patterns: List[Tree]): Unapply =
@@ -1443,11 +1443,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Alternatives = tpd.Alternative
 
-    object AlternativesTypeTest extends TypeTest[Tree, Alternatives]:
+    object AlternativesTypeTestImpl extends TypeTest[Tree, Alternatives]:
       def unapply(x: Tree): Option[Alternatives & x.type] = x match
         case x: (tpd.Alternative & x.type) => Some(x)
         case _ => None
-    end AlternativesTypeTest
+    end AlternativesTypeTestImpl
 
     object Alternatives extends AlternativesModule:
       def apply(patterns: List[Tree]): Alternatives =
@@ -1470,11 +1470,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type SimpleSelector = untpd.ImportSelector
 
-    object SimpleSelectorTypeTest extends TypeTest[ImportSelector, SimpleSelector]:
+    object SimpleSelectorTypeTestImpl extends TypeTest[ImportSelector, SimpleSelector]:
       def unapply(x: ImportSelector): Option[SimpleSelector & x.type] = x match
         case x: (untpd.ImportSelector & x.type) if x.renamed.isEmpty && !x.isGiven => Some(x)
         case _ => None // TODO: handle import bounds
-    end SimpleSelectorTypeTest
+    end SimpleSelectorTypeTestImpl
 
     object SimpleSelector extends SimpleSelectorModule:
       def unapply(x: SimpleSelector): Option[String] = Some(x.name.toString)
@@ -1490,11 +1490,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type RenameSelector = untpd.ImportSelector
 
-    object RenameSelectorTypeTest extends TypeTest[ImportSelector, RenameSelector]:
+    object RenameSelectorTypeTestImpl extends TypeTest[ImportSelector, RenameSelector]:
       def unapply(x: ImportSelector): Option[RenameSelector & x.type] = x match
         case x: (untpd.ImportSelector & x.type) if !x.renamed.isEmpty => Some(x)
         case _ => None
-    end RenameSelectorTypeTest
+    end RenameSelectorTypeTestImpl
 
     object RenameSelector extends RenameSelectorModule:
       def unapply(x: RenameSelector): Option[(String, String)] = Some((x.fromName, x.toName))
@@ -1511,7 +1511,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type OmitSelector = untpd.ImportSelector
 
-    object OmitSelectorTypeTest extends TypeTest[ImportSelector, OmitSelector]:
+    object OmitSelectorTypeTestImpl extends TypeTest[ImportSelector, OmitSelector]:
       def unapply(x: ImportSelector): Option[OmitSelector & x.type] = x match {
         case self: (untpd.ImportSelector & x.type) =>
           self.renamed match
@@ -1519,7 +1519,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
             case _ => None
         case _ => None
       }
-    end OmitSelectorTypeTest
+    end OmitSelectorTypeTestImpl
 
     object OmitSelector extends OmitSelectorModule:
       def unapply(x: OmitSelector): Option[String] = Some(x.imported.name.toString)
@@ -1534,12 +1534,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type GivenSelector = untpd.ImportSelector
 
-    object GivenSelectorTypeTest extends TypeTest[ImportSelector, GivenSelector]:
+    object GivenSelectorTypeTestImpl extends TypeTest[ImportSelector, GivenSelector]:
       def unapply(x: ImportSelector): Option[GivenSelector & x.type] = x match {
         case self: (untpd.ImportSelector & x.type) if x.isGiven => Some(self)
         case _ => None
       }
-    end GivenSelectorTypeTest
+    end GivenSelectorTypeTestImpl
 
     object GivenSelector extends GivenSelectorModule:
       def unapply(x: GivenSelector): Option[Option[TypeTree]] =
@@ -1635,11 +1635,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ConstantType = dotc.core.Types.ConstantType
 
-    object ConstantTypeTypeTest extends TypeTest[TypeRepr, ConstantType]:
+    object ConstantTypeTypeTestImpl extends TypeTest[TypeRepr, ConstantType]:
       def unapply(x: TypeRepr): Option[ConstantType & x.type] = x match
         case tpe: (Types.ConstantType & x.type) => Some(tpe)
         case _ => None
-    end ConstantTypeTypeTest
+    end ConstantTypeTypeTestImpl
 
     object ConstantType extends ConstantTypeModule:
       def apply(const: Constant): ConstantType = Types.ConstantType(const)
@@ -1652,11 +1652,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TermRef = dotc.core.Types.NamedType
 
-    object TermRefTypeTest extends TypeTest[TypeRepr, TermRef]:
+    object TermRefTypeTestImpl extends TypeTest[TypeRepr, TermRef]:
       def unapply(x: TypeRepr): Option[TermRef & x.type] = x match
         case tpe: (Types.TermRef & x.type) => Some(tpe)
         case _ => None
-    end TermRefTypeTest
+    end TermRefTypeTestImpl
 
     object TermRef extends TermRefModule:
       def apply(qual: TypeRepr, name: String): TermRef =
@@ -1674,11 +1674,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeRef = dotc.core.Types.NamedType
 
-    object TypeRefTypeTest extends TypeTest[TypeRepr, TypeRef]:
+    object TypeRefTypeTestImpl extends TypeTest[TypeRepr, TypeRef]:
       def unapply(x: TypeRepr): Option[TypeRef & x.type] = x match
         case tpe: (Types.TypeRef & x.type) => Some(tpe)
         case _ => None
-    end TypeRefTypeTest
+    end TypeRefTypeTestImpl
 
     object TypeRef extends TypeRefModule:
       def unapply(x: TypeRef): Option[(TypeRepr, String)] =
@@ -1696,11 +1696,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type SuperType = dotc.core.Types.SuperType
 
-    object SuperTypeTypeTest extends TypeTest[TypeRepr, SuperType]:
+    object SuperTypeTypeTestImpl extends TypeTest[TypeRepr, SuperType]:
       def unapply(x: TypeRepr): Option[SuperType & x.type] = x match
         case tpe: (Types.SuperType & x.type) => Some(tpe)
         case _ => None
-    end SuperTypeTypeTest
+    end SuperTypeTypeTestImpl
 
     object SuperType extends SuperTypeModule:
       def apply(thistpe: TypeRepr, supertpe: TypeRepr): SuperType =
@@ -1718,11 +1718,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type Refinement = dotc.core.Types.RefinedType
 
-    object RefinementTypeTest extends TypeTest[TypeRepr, Refinement]:
+    object RefinementTypeTestImpl extends TypeTest[TypeRepr, Refinement]:
       def unapply(x: TypeRepr): Option[Refinement & x.type] = x match
         case tpe: (Types.RefinedType & x.type) => Some(tpe)
         case _ => None
-    end RefinementTypeTest
+    end RefinementTypeTestImpl
 
     object Refinement extends RefinementModule:
       def apply(parent: TypeRepr, name: String, info: TypeRepr): Refinement =
@@ -1745,11 +1745,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type AppliedType = dotc.core.Types.AppliedType
 
-    object AppliedTypeTypeTest extends TypeTest[TypeRepr, AppliedType]:
+    object AppliedTypeTypeTestImpl extends TypeTest[TypeRepr, AppliedType]:
       def unapply(x: TypeRepr): Option[AppliedType & x.type] = x match
         case tpe: (Types.AppliedType & x.type) => Some(tpe)
         case _ => None
-    end AppliedTypeTypeTest
+    end AppliedTypeTypeTestImpl
 
     object AppliedType extends AppliedTypeModule:
       def unapply(x: AppliedType): Option[(TypeRepr, List[TypeRepr])] =
@@ -1765,11 +1765,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type AnnotatedType = dotc.core.Types.AnnotatedType
 
-    object AnnotatedTypeTypeTest extends TypeTest[TypeRepr, AnnotatedType]:
+    object AnnotatedTypeTypeTestImpl extends TypeTest[TypeRepr, AnnotatedType]:
       def unapply(x: TypeRepr): Option[AnnotatedType & x.type] = x match
         case tpe: (Types.AnnotatedType & x.type) => Some(tpe)
         case _ => None
-    end AnnotatedTypeTypeTest
+    end AnnotatedTypeTypeTestImpl
 
     object AnnotatedType extends AnnotatedTypeModule:
       def apply(underlying: TypeRepr, annot: Term): AnnotatedType =
@@ -1787,11 +1787,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type AndType = dotc.core.Types.AndType
 
-    object AndTypeTypeTest extends TypeTest[TypeRepr, AndType]:
+    object AndTypeTypeTestImpl extends TypeTest[TypeRepr, AndType]:
       def unapply(x: TypeRepr): Option[AndType & x.type] = x match
         case tpe: (Types.AndType & x.type) => Some(tpe)
         case _ => None
-    end AndTypeTypeTest
+    end AndTypeTypeTestImpl
 
     object AndType extends AndTypeModule:
       def apply(lhs: TypeRepr, rhs: TypeRepr): AndType = Types.AndType(lhs, rhs)
@@ -1807,11 +1807,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type OrType = dotc.core.Types.OrType
 
-    object OrTypeTypeTest extends TypeTest[TypeRepr, OrType]:
+    object OrTypeTypeTestImpl extends TypeTest[TypeRepr, OrType]:
       def unapply(x: TypeRepr): Option[OrType & x.type] = x match
         case tpe: (Types.OrType & x.type) => Some(tpe)
         case _ => None
-    end OrTypeTypeTest
+    end OrTypeTypeTestImpl
 
     object OrType extends OrTypeModule:
       def apply(lhs: TypeRepr, rhs: TypeRepr): OrType = Types.OrType(lhs, rhs, soft = false)
@@ -1827,11 +1827,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type MatchType = dotc.core.Types.MatchType
 
-    object MatchTypeTypeTest extends TypeTest[TypeRepr, MatchType]:
+    object MatchTypeTypeTestImpl extends TypeTest[TypeRepr, MatchType]:
       def unapply(x: TypeRepr): Option[MatchType & x.type] = x match
         case tpe: (Types.MatchType & x.type) => Some(tpe)
         case _ => None
-    end MatchTypeTypeTest
+    end MatchTypeTypeTestImpl
 
     object MatchType extends MatchTypeModule:
       def apply(bound: TypeRepr, scrutinee: TypeRepr, cases: List[TypeRepr]): MatchType =
@@ -1850,11 +1850,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ByNameType = dotc.core.Types.ExprType
 
-    object ByNameTypeTypeTest extends TypeTest[TypeRepr, ByNameType]:
+    object ByNameTypeTypeTestImpl extends TypeTest[TypeRepr, ByNameType]:
       def unapply(x: TypeRepr): Option[ByNameType & x.type] = x match
         case tpe: (Types.ExprType & x.type) => Some(tpe)
         case _ => None
-    end ByNameTypeTypeTest
+    end ByNameTypeTypeTestImpl
 
     object ByNameType extends ByNameTypeModule:
       def apply(underlying: TypeRepr): TypeRepr = Types.ExprType(underlying)
@@ -1869,12 +1869,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ParamRef = dotc.core.Types.ParamRef
 
-    object ParamRefTypeTest extends TypeTest[TypeRepr, ParamRef]:
+    object ParamRefTypeTestImpl extends TypeTest[TypeRepr, ParamRef]:
       def unapply(x: TypeRepr): Option[ParamRef & x.type] = x match
         case tpe: (Types.TypeParamRef & x.type) => Some(tpe)
         case tpe: (Types.TermParamRef & x.type) => Some(tpe)
         case _ => None
-    end ParamRefTypeTest
+    end ParamRefTypeTestImpl
 
     object ParamRef extends ParamRefModule:
       def unapply(x: ParamRef): Option[(LambdaType, Int)] =
@@ -1890,11 +1890,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ThisType = dotc.core.Types.ThisType
 
-    object ThisTypeTypeTest extends TypeTest[TypeRepr, ThisType]:
+    object ThisTypeTypeTestImpl extends TypeTest[TypeRepr, ThisType]:
       def unapply(x: TypeRepr): Option[ThisType & x.type] = x match
         case tpe: (Types.ThisType & x.type) => Some(tpe)
         case _ => None
-    end ThisTypeTypeTest
+    end ThisTypeTypeTestImpl
 
     object ThisType extends ThisTypeModule:
       def unapply(x: ThisType): Option[TypeRepr] = Some(x.tref)
@@ -1908,11 +1908,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type RecursiveThis = dotc.core.Types.RecThis
 
-    object RecursiveThisTypeTest extends TypeTest[TypeRepr, RecursiveThis]:
+    object RecursiveThisTypeTestImpl extends TypeTest[TypeRepr, RecursiveThis]:
       def unapply(x: TypeRepr): Option[RecursiveThis & x.type] = x match
         case tpe: (Types.RecThis & x.type) => Some(tpe)
         case _ => None
-    end RecursiveThisTypeTest
+    end RecursiveThisTypeTestImpl
 
     object RecursiveThis extends RecursiveThisModule:
       def unapply(x: RecursiveThis): Option[RecursiveType] = Some(x.binder)
@@ -1927,11 +1927,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type RecursiveType = dotc.core.Types.RecType
 
-    object RecursiveTypeTypeTest extends TypeTest[TypeRepr, RecursiveType]:
+    object RecursiveTypeTypeTestImpl extends TypeTest[TypeRepr, RecursiveType]:
       def unapply(x: TypeRepr): Option[RecursiveType & x.type] = x match
         case tpe: (Types.RecType & x.type) => Some(tpe)
         case _ => None
-    end RecursiveTypeTypeTest
+    end RecursiveTypeTypeTestImpl
 
     object RecursiveType extends RecursiveTypeModule:
       def apply(parentExp: RecursiveType => TypeRepr): RecursiveType =
@@ -1950,11 +1950,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type MethodType = dotc.core.Types.MethodType
 
-    object MethodTypeTypeTest extends TypeTest[TypeRepr, MethodType]:
+    object MethodTypeTypeTestImpl extends TypeTest[TypeRepr, MethodType]:
       def unapply(x: TypeRepr): Option[MethodType & x.type] = x match
         case tpe: (Types.MethodType & x.type) => Some(tpe)
         case _ => None
-    end MethodTypeTypeTest
+    end MethodTypeTypeTestImpl
 
     object MethodType extends MethodTypeModule:
       def apply(paramNames: List[String])(paramInfosExp: MethodType => List[TypeRepr], resultTypeExp: MethodType => TypeRepr): MethodType =
@@ -1976,11 +1976,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type PolyType = dotc.core.Types.PolyType
 
-    object PolyTypeTypeTest extends TypeTest[TypeRepr, PolyType]:
+    object PolyTypeTypeTestImpl extends TypeTest[TypeRepr, PolyType]:
       def unapply(x: TypeRepr): Option[PolyType & x.type] = x match
         case tpe: (Types.PolyType & x.type) => Some(tpe)
         case _ => None
-    end PolyTypeTypeTest
+    end PolyTypeTypeTestImpl
 
     object PolyType extends PolyTypeModule:
       def apply(paramNames: List[String])(paramBoundsExp: PolyType => List[TypeBounds], resultTypeExp: PolyType => TypeRepr): PolyType =
@@ -2000,11 +2000,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeLambda = dotc.core.Types.TypeLambda
 
-    object TypeLambdaTypeTest extends TypeTest[TypeRepr, TypeLambda]:
+    object TypeLambdaTypeTestImpl extends TypeTest[TypeRepr, TypeLambda]:
       def unapply(x: TypeRepr): Option[TypeLambda & x.type] = x match
         case tpe: (Types.TypeLambda & x.type) => Some(tpe)
         case _ => None
-    end TypeLambdaTypeTest
+    end TypeLambdaTypeTestImpl
 
     object TypeLambda extends TypeLambdaModule:
       def apply(paramNames: List[String], boundsFn: TypeLambda => List[TypeBounds], bodyFn: TypeLambda => TypeRepr): TypeLambda =
@@ -2024,11 +2024,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type TypeBounds = dotc.core.Types.TypeBounds
 
-    object TypeBoundsTypeTest extends TypeTest[TypeRepr, TypeBounds]:
+    object TypeBoundsTypeTestImpl extends TypeTest[TypeRepr, TypeBounds]:
       def unapply(x: TypeRepr): Option[TypeBounds & x.type] = x match
         case x: (Types.TypeBounds & x.type) => Some(x)
         case _ => None
-    end TypeBoundsTypeTest
+    end TypeBoundsTypeTestImpl
 
     object TypeBounds extends TypeBoundsModule:
       def apply(low: TypeRepr, hi: TypeRepr): TypeBounds = Types.TypeBounds(low, hi)
@@ -2047,10 +2047,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type NoPrefix = dotc.core.Types.NoPrefix.type
 
-    object NoPrefixTypeTest extends TypeTest[TypeRepr, NoPrefix]:
+    object NoPrefixTypeTestImpl extends TypeTest[TypeRepr, NoPrefix]:
       def unapply(x: TypeRepr): Option[NoPrefix & x.type] =
         if x == Types.NoPrefix then Some(x.asInstanceOf[NoPrefix & x.type]) else None
-    end NoPrefixTypeTest
+    end NoPrefixTypeTestImpl
 
     object NoPrefix extends NoPrefixModule:
       def unapply(x: NoPrefix): Boolean = true
@@ -2167,12 +2167,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ImplicitSearchSuccess = Tree
 
-    object ImplicitSearchSuccessTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]:
+    object ImplicitSearchSuccessTypeTestImpl extends TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]:
       def unapply(x: ImplicitSearchResult): Option[ImplicitSearchSuccess & x.type] =
         x.tpe match
           case _: dotc.typer.Implicits.SearchFailureType => None
           case _ => Some(x)
-    end ImplicitSearchSuccessTypeTest
+    end ImplicitSearchSuccessTypeTestImpl
 
     object ImplicitSearchSuccessMethodsImpl extends ImplicitSearchSuccessMethods:
       extension (self: ImplicitSearchSuccess):
@@ -2182,12 +2182,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type ImplicitSearchFailure = Tree
 
-    object ImplicitSearchFailureTypeTest extends TypeTest[ImplicitSearchResult, ImplicitSearchFailure]:
+    object ImplicitSearchFailureTypeTestImpl extends TypeTest[ImplicitSearchResult, ImplicitSearchFailure]:
       def unapply(x: ImplicitSearchResult): Option[ImplicitSearchFailure & x.type] =
         x.tpe match
           case _: dotc.typer.Implicits.SearchFailureType => Some(x)
           case _ => None
-    end ImplicitSearchFailureTypeTest
+    end ImplicitSearchFailureTypeTestImpl
 
     object ImplicitSearchFailureMethodsImpl extends ImplicitSearchFailureMethods:
       extension (self: ImplicitSearchFailure):
@@ -2198,30 +2198,30 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     type DivergingImplicit = Tree
 
-    object DivergingImplicitTypeTest extends TypeTest[ImplicitSearchResult, DivergingImplicit]:
+    object DivergingImplicitTypeTestImpl extends TypeTest[ImplicitSearchResult, DivergingImplicit]:
       def unapply(x: ImplicitSearchResult): Option[DivergingImplicit & x.type] =
         x.tpe match
           case _: dotc.typer.Implicits.DivergingImplicit => Some(x)
           case _ => None
-    end DivergingImplicitTypeTest
+    end DivergingImplicitTypeTestImpl
 
     type NoMatchingImplicits = Tree
 
-    object NoMatchingImplicitsTypeTest extends TypeTest[ImplicitSearchResult, NoMatchingImplicits]:
+    object NoMatchingImplicitsTypeTestImpl extends TypeTest[ImplicitSearchResult, NoMatchingImplicits]:
       def unapply(x: ImplicitSearchResult): Option[NoMatchingImplicits & x.type] =
         x.tpe match
           case _: dotc.typer.Implicits.NoMatchingImplicits => Some(x)
           case _ => None
-    end NoMatchingImplicitsTypeTest
+    end NoMatchingImplicitsTypeTestImpl
 
     type AmbiguousImplicits = Tree
 
-    object AmbiguousImplicitsTypeTest extends TypeTest[ImplicitSearchResult, AmbiguousImplicits]:
+    object AmbiguousImplicitsTypeTestImpl extends TypeTest[ImplicitSearchResult, AmbiguousImplicits]:
       def unapply(x: ImplicitSearchResult): Option[AmbiguousImplicits & x.type] =
         x.tpe match
           case _: dotc.typer.Implicits.AmbiguousImplicits => Some(x)
           case _ => None
-    end AmbiguousImplicitsTypeTest
+    end AmbiguousImplicitsTypeTestImpl
 
     type Symbol = dotc.core.Symbols.Symbol
 
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 17eabebd3af0..539fc5d4b4dd 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -243,10 +243,10 @@ 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 TypeTest[Tree, PackageClause] = PackageClauseTypeTest
+    given PackageClauseTypeTest as TypeTest[Tree, PackageClause] = PackageClauseTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, PackageClause]` */
-    protected val PackageClauseTypeTest: TypeTest[Tree, PackageClause]
+    /** Implementation of `PackageClauseTypeTest` */
+    protected val PackageClauseTypeTestImpl: TypeTest[Tree, PackageClause]
 
     /** Module object of `type PackageClause`  */
     val PackageClause: PackageClauseModule
@@ -276,10 +276,10 @@ 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 TypeTest[Tree, Import] = ImportTypeTest
+    given ImportTypeTest as TypeTest[Tree, Import] = ImportTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Import]` */
-    protected val ImportTypeTest: TypeTest[Tree, Import]
+    /** Implementation of `ImportTypeTest` */
+    protected val ImportTypeTestImpl: TypeTest[Tree, Import]
 
     /** Module object of `type Import`  */
     val Import: ImportModule
@@ -309,10 +309,10 @@ 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 TypeTest[Tree, Statement] = StatementTypeTest
+    given StatementTypeTest as TypeTest[Tree, Statement] = StatementTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Statement]` */
-    protected val StatementTypeTest: TypeTest[Tree, Statement]
+    /** Implementation of `StatementTypeTest` */
+    protected val StatementTypeTestImpl: TypeTest[Tree, Statement]
 
     // ----- Definitions ----------------------------------------------
 
@@ -320,10 +320,10 @@ 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 TypeTest[Tree, Definition] = DefinitionTypeTest
+    given DefinitionTypeTest as TypeTest[Tree, Definition] = DefinitionTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Definition]` */
-    protected val DefinitionTypeTest: TypeTest[Tree, Definition]
+    /** Implementation of `DefinitionTypeTest` */
+    protected val DefinitionTypeTestImpl: TypeTest[Tree, Definition]
 
     /** Module object of `type Definition`  */
     val Definition: DefinitionModule
@@ -350,10 +350,10 @@ 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 TypeTest[Tree, ClassDef] = ClassDefTypeTest
+    given ClassDefTypeTest as TypeTest[Tree, ClassDef] = ClassDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, ClassDef]` */
-    protected val ClassDefTypeTest: TypeTest[Tree, ClassDef]
+    /** Implementation of `ClassDefTypeTest` */
+    protected val ClassDefTypeTestImpl: TypeTest[Tree, ClassDef]
 
     /** Module object of `type ClassDef`  */
     val ClassDef: ClassDefModule
@@ -388,10 +388,10 @@ 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 TypeTest[Tree, DefDef] = DefDefTypeTest
+    given DefDefTypeTest as TypeTest[Tree, DefDef] = DefDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, DefDef]` */
-    protected val DefDefTypeTest: TypeTest[Tree, DefDef]
+    /** Implementation of `DefDefTypeTest` */
+    protected val DefDefTypeTestImpl: TypeTest[Tree, DefDef]
 
     /** Module object of `type DefDef`  */
     val DefDef: DefDefModule
@@ -425,10 +425,10 @@ 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 TypeTest[Tree, ValDef] = ValDefTypeTest
+    given ValDefTypeTest as TypeTest[Tree, ValDef] = ValDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, ValDef]` */
-    protected val ValDefTypeTest: TypeTest[Tree, ValDef]
+    /** Implementation of `ValDefTypeTest` */
+    protected val ValDefTypeTestImpl: TypeTest[Tree, ValDef]
 
     /** Module object of `type ValDef`  */
     val ValDef: ValDefModule
@@ -470,10 +470,10 @@ 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 TypeTest[Tree, TypeDef] = TypeDefTypeTest
+    given TypeDefTypeTest as TypeTest[Tree, TypeDef] = TypeDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeDef]` */
-    protected val TypeDefTypeTest: TypeTest[Tree, TypeDef]
+    /** Implementation of `TypeDefTypeTest` */
+    protected val TypeDefTypeTestImpl: TypeTest[Tree, TypeDef]
 
     /** Module object of `type TypeDef`  */
     val TypeDef: TypeDefModule
@@ -505,10 +505,10 @@ 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 TypeTest[Tree, Term] = TermTypeTest
+    given TermTypeTest as TypeTest[Tree, Term] = TermTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Term]` */
-    protected val TermTypeTest: TypeTest[Tree, Term]
+    /** Implementation of `TermTypeTest` */
+    protected val TermTypeTestImpl: TypeTest[Tree, Term]
 
     /** Module object of `type Term`  */
     val Term: TermModule
@@ -591,10 +591,10 @@ 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 TypeTest[Tree, Ref] = RefTypeTest
+    given RefTypeTest as TypeTest[Tree, Ref] = RefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Ref]` */
-    protected val RefTypeTest: TypeTest[Tree, Ref]
+    /** Implementation of `RefTypeTest` */
+    protected val RefTypeTestImpl: TypeTest[Tree, Ref]
 
     /** Module object of `type Ref`  */
     val Ref: RefModule
@@ -626,10 +626,10 @@ 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 TypeTest[Tree, Ident] = IdentTypeTest
+    given IdentTypeTest as TypeTest[Tree, Ident] = IdentTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Ident]` */
-    protected val IdentTypeTest: TypeTest[Tree, Ident]
+    /** Implementation of `IdentTypeTest` */
+    protected val IdentTypeTestImpl: TypeTest[Tree, Ident]
 
     /** Module object of `type Ident`  */
     val Ident: IdentModule
@@ -661,10 +661,10 @@ 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 TypeTest[Tree, Select] = SelectTypeTest
+    given SelectTypeTest as TypeTest[Tree, Select] = SelectTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Select]` */
-    protected val SelectTypeTest: TypeTest[Tree, Select]
+    /** Implementation of `SelectTypeTest` */
+    protected val SelectTypeTestImpl: TypeTest[Tree, Select]
 
     /** Module object of `type Select`  */
     val Select: SelectModule
@@ -710,10 +710,10 @@ 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 TypeTest[Tree, Literal] = LiteralTypeTest
+    given LiteralTypeTest as TypeTest[Tree, Literal] = LiteralTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Literal]` */
-    protected val LiteralTypeTest: TypeTest[Tree, Literal]
+    /** Implementation of `LiteralTypeTest` */
+    protected val LiteralTypeTestImpl: TypeTest[Tree, Literal]
 
     /** Tree representing a literal value in the source code */
     type Literal <: Term
@@ -750,10 +750,10 @@ 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 TypeTest[Tree, This] = ThisTypeTest
+    given ThisTypeTest as TypeTest[Tree, This] = ThisTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, This]` */
-    protected val ThisTypeTest: TypeTest[Tree, This]
+    /** Implementation of `ThisTypeTest` */
+    protected val ThisTypeTestImpl: TypeTest[Tree, This]
 
     /** Module object of `type This`  */
     val This: ThisModule
@@ -787,10 +787,10 @@ 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 TypeTest[Tree, New] = NewTypeTest
+    given NewTypeTest as TypeTest[Tree, New] = NewTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, New]` */
-    protected val NewTypeTest: TypeTest[Tree, New]
+    /** Implementation of `NewTypeTest` */
+    protected val NewTypeTestImpl: TypeTest[Tree, New]
 
     /** Module object of `type New`  */
     val New: NewModule
@@ -824,10 +824,10 @@ 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 TypeTest[Tree, NamedArg] = NamedArgTypeTest
+    given NamedArgTypeTest as TypeTest[Tree, NamedArg] = NamedArgTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, NamedArg]` */
-    protected val NamedArgTypeTest: TypeTest[Tree, NamedArg]
+    /** Implementation of `NamedArgTypeTest` */
+    protected val NamedArgTypeTestImpl: TypeTest[Tree, NamedArg]
 
     /** Module object of `type NamedArg`  */
     val NamedArg: NamedArgModule
@@ -862,10 +862,10 @@ 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 TypeTest[Tree, Apply] = ApplyTypeTest
+    given ApplyTypeTest as TypeTest[Tree, Apply] = ApplyTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Apply]` */
-    protected val ApplyTypeTest: TypeTest[Tree, Apply]
+    /** Implementation of `ApplyTypeTest` */
+    protected val ApplyTypeTestImpl: TypeTest[Tree, Apply]
 
     /** Module object of `type Apply`  */
     val Apply: ApplyModule
@@ -900,10 +900,10 @@ 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 TypeTest[Tree, TypeApply] = TypeApplyTypeTest
+    given TypeApplyTypeTest as TypeTest[Tree, TypeApply] = TypeApplyTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeApply]` */
-    protected val TypeApplyTypeTest: TypeTest[Tree, TypeApply]
+    /** Implementation of `TypeApplyTypeTest` */
+    protected val TypeApplyTypeTestImpl: TypeTest[Tree, TypeApply]
 
     /** Module object of `type TypeApply`  */
     val TypeApply: TypeApplyModule
@@ -935,10 +935,10 @@ 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 TypeTest[Tree, Super] = SuperTypeTest
+    given SuperTypeTest as TypeTest[Tree, Super] = SuperTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Super]` */
-    protected val SuperTypeTest: TypeTest[Tree, Super]
+    /** Implementation of `SuperTypeTest` */
+    protected val SuperTypeTestImpl: TypeTest[Tree, Super]
 
     /** Tree representing `super` in the source code */
     type Super <: Term
@@ -974,10 +974,10 @@ 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 TypeTest[Tree, Typed] = TypedTypeTest
+    given TypedTypeTest as TypeTest[Tree, Typed] = TypedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Typed]` */
-    protected val TypedTypeTest: TypeTest[Tree, Typed]
+    /** Implementation of `TypedTypeTest` */
+    protected val TypedTypeTestImpl: TypeTest[Tree, Typed]
 
     /** Tree representing a type ascription `x: T` in the source code */
     type Typed <: Term
@@ -1015,10 +1015,10 @@ 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 TypeTest[Tree, Assign] = AssignTypeTest
+    given AssignTypeTest as TypeTest[Tree, Assign] = AssignTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Assign]` */
-    protected val AssignTypeTest: TypeTest[Tree, Assign]
+    /** Implementation of `AssignTypeTest` */
+    protected val AssignTypeTestImpl: TypeTest[Tree, Assign]
 
     /** Module object of `type Assign`  */
     val Assign: AssignModule
@@ -1053,10 +1053,10 @@ 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 TypeTest[Tree, Block] = BlockTypeTest
+    given BlockTypeTest as TypeTest[Tree, Block] = BlockTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Block]` */
-    protected val BlockTypeTest: TypeTest[Tree, Block]
+    /** Implementation of `BlockTypeTest` */
+    protected val BlockTypeTestImpl: TypeTest[Tree, Block]
 
     /** Module object of `type Block`  */
     val Block: BlockModule
@@ -1088,10 +1088,10 @@ 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 TypeTest[Tree, Closure] = ClosureTypeTest
+    given ClosureTypeTest as TypeTest[Tree, Closure] = ClosureTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Closure]` */
-    protected val ClosureTypeTest: TypeTest[Tree, Closure]
+    /** Implementation of `ClosureTypeTest` */
+    protected val ClosureTypeTestImpl: TypeTest[Tree, Closure]
 
     /** A lambda `(...) => ...` in the source code is represented as
      *  a local method and a closure:
@@ -1168,10 +1168,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     }
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `Tree` is an `If` */
-    given TypeTest[Tree, If] = IfTypeTest
+    given IfTypeTest as TypeTest[Tree, If] = IfTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, If]` */
-    protected val IfTypeTest: TypeTest[Tree, If]
+    /** Implementation of `IfTypeTest` */
+    protected val IfTypeTestImpl: TypeTest[Tree, If]
 
     /** Tree representing an if/then/else `if (...) ... else ...` in the source code */
     type If <: Term
@@ -1210,10 +1210,10 @@ 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 TypeTest[Tree, Match] = MatchTypeTest
+    given MatchTypeTest as TypeTest[Tree, Match] = MatchTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Match]` */
-    protected val MatchTypeTest: TypeTest[Tree, Match]
+    /** Implementation of `MatchTypeTest` */
+    protected val MatchTypeTestImpl: TypeTest[Tree, Match]
 
     /** Module object of `type Match`  */
     val Match: MatchModule
@@ -1248,10 +1248,10 @@ 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 TypeTest[Tree, SummonFrom] = SummonFromTypeTest
+    given SummonFromTypeTest as TypeTest[Tree, SummonFrom] = SummonFromTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, SummonFrom]` */
-    protected val SummonFromTypeTest: TypeTest[Tree, SummonFrom]
+    /** Implementation of `SummonFromTypeTest` */
+    protected val SummonFromTypeTestImpl: TypeTest[Tree, SummonFrom]
 
     /** Module object of `type SummonFrom`  */
     val SummonFrom: SummonFromModule
@@ -1285,10 +1285,10 @@ 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 TypeTest[Tree, Try] = TryTypeTest
+    given TryTypeTest as TypeTest[Tree, Try] = TryTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Try]` */
-    protected val TryTypeTest: TypeTest[Tree, Try]
+    /** Implementation of `TryTypeTest` */
+    protected val TryTypeTestImpl: TypeTest[Tree, Try]
 
     /** Module object of `type Try`  */
     val Try: TryModule
@@ -1321,10 +1321,10 @@ 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 TypeTest[Tree, Return] = ReturnTypeTest
+    given ReturnTypeTest as TypeTest[Tree, Return] = ReturnTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Return]` */
-    protected val ReturnTypeTest: TypeTest[Tree, Return]
+    /** Implementation of `ReturnTypeTest` */
+    protected val ReturnTypeTestImpl: TypeTest[Tree, Return]
 
     /** Tree representing a `return` in the source code */
     type Return <: Term
@@ -1362,10 +1362,10 @@ 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 TypeTest[Tree, Repeated] = RepeatedTypeTest
+    given RepeatedTypeTest as TypeTest[Tree, Repeated] = RepeatedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Repeated]` */
-    protected val RepeatedTypeTest: TypeTest[Tree, Repeated]
+    /** Implementation of `RepeatedTypeTest` */
+    protected val RepeatedTypeTestImpl: TypeTest[Tree, Repeated]
 
     /** Module object of `type Repeated`  */
     val Repeated: RepeatedModule
@@ -1395,10 +1395,10 @@ 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 TypeTest[Tree, Inlined] = InlinedTypeTest
+    given InlinedTypeTest as TypeTest[Tree, Inlined] = InlinedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Inlined]` */
-    protected val InlinedTypeTest: TypeTest[Tree, Inlined]
+    /** Implementation of `InlinedTypeTest` */
+    protected val InlinedTypeTestImpl: TypeTest[Tree, Inlined]
 
     /** Module object of `type Inlined`  */
     val Inlined: InlinedModule
@@ -1429,10 +1429,10 @@ 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 TypeTest[Tree, SelectOuter] = SelectOuterTypeTest
+    given SelectOuterTypeTest as TypeTest[Tree, SelectOuter] = SelectOuterTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, SelectOuter]` */
-    protected val SelectOuterTypeTest: TypeTest[Tree, SelectOuter]
+    /** Implementation of `SelectOuterTypeTest` */
+    protected val SelectOuterTypeTestImpl: TypeTest[Tree, SelectOuter]
 
     /** Module object of `type SelectOuter`  */
     val SelectOuter: SelectOuterModule
@@ -1463,10 +1463,10 @@ 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 TypeTest[Tree, While] = WhileTypeTest
+    given WhileTypeTest as TypeTest[Tree, While] = WhileTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, While]` */
-    protected val WhileTypeTest: TypeTest[Tree, While]
+    /** Implementation of `WhileTypeTest` */
+    protected val WhileTypeTestImpl: TypeTest[Tree, While]
 
     /** Module object of `type While`  */
     val While: WhileModule
@@ -1503,10 +1503,10 @@ 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 TypeTest[Tree, TypeTree] = TypeTreeTypeTest
+    given TypeTreeTypeTest as TypeTest[Tree, TypeTree] = TypeTreeTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeTree]` */
-    protected val TypeTreeTypeTest: TypeTest[Tree, TypeTree]
+    /** Implementation of `TypeTreeTypeTest` */
+    protected val TypeTreeTypeTestImpl: TypeTest[Tree, TypeTree]
 
     /** Module object of `type TypeTree`  */
     val TypeTree: TypeTreeModule
@@ -1535,10 +1535,10 @@ 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 TypeTest[Tree, Inferred] = InferredTypeTest
+    given InferredTypeTest as TypeTest[Tree, Inferred] = InferredTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Inferred]` */
-    protected val InferredTypeTest: TypeTest[Tree, Inferred]
+    /** Implementation of `InferredTypeTest` */
+    protected val InferredTypeTestImpl: TypeTest[Tree, Inferred]
 
     /** Module object of `type Inferred`  */
     val Inferred: InferredModule
@@ -1554,10 +1554,10 @@ 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 TypeTest[Tree, TypeIdent] = TypeIdentTypeTest
+    given TypeIdentTypeTest as TypeTest[Tree, TypeIdent] = TypeIdentTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeIdent]` */
-    protected val TypeIdentTypeTest: TypeTest[Tree, TypeIdent]
+    /** Implementation of `TypeIdentTypeTest` */
+    protected val TypeIdentTypeTestImpl: TypeTest[Tree, TypeIdent]
 
     /** Module object of `type TypeIdent`  */
     val TypeIdent: TypeIdentModule
@@ -1586,10 +1586,10 @@ 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 TypeTest[Tree, TypeSelect] = TypeSelectTypeTest
+    given TypeSelectTypeTest as TypeTest[Tree, TypeSelect] = TypeSelectTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeSelect]` */
-    protected val TypeSelectTypeTest: TypeTest[Tree, TypeSelect]
+    /** Implementation of `TypeSelectTypeTest` */
+    protected val TypeSelectTypeTestImpl: TypeTest[Tree, TypeSelect]
 
     /** Module object of `type TypeSelect`  */
     val TypeSelect: TypeSelectModule
@@ -1619,10 +1619,10 @@ 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 TypeTest[Tree, TypeProjection] = TypeProjectionTypeTest
+    given TypeProjectionTypeTest as TypeTest[Tree, TypeProjection] = TypeProjectionTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeProjection]` */
-    protected val TypeProjectionTypeTest: TypeTest[Tree, TypeProjection]
+    /** Implementation of `TypeProjectionTypeTest` */
+    protected val TypeProjectionTypeTestImpl: TypeTest[Tree, TypeProjection]
 
     /** Module object of `type TypeProjection`  */
     val TypeProjection: TypeProjectionModule
@@ -1652,10 +1652,10 @@ 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 TypeTest[Tree, Singleton] = SingletonTypeTest
+    given SingletonTypeTest as TypeTest[Tree, Singleton] = SingletonTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Singleton]` */
-    protected val SingletonTypeTest: TypeTest[Tree, Singleton]
+    /** Implementation of `SingletonTypeTest` */
+    protected val SingletonTypeTestImpl: TypeTest[Tree, Singleton]
 
     /** Module object of `type Singleton`  */
     val Singleton: SingletonModule
@@ -1684,10 +1684,10 @@ 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 TypeTest[Tree, Refined] = RefinedTypeTest
+    given RefinedTypeTest as TypeTest[Tree, Refined] = RefinedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Refined]` */
-    protected val RefinedTypeTest: TypeTest[Tree, Refined]
+    /** Implementation of `RefinedTypeTest` */
+    protected val RefinedTypeTestImpl: TypeTest[Tree, Refined]
 
     /** Module object of `type Refined`  */
     val Refined: RefinedModule
@@ -1717,10 +1717,10 @@ 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 TypeTest[Tree, Applied] = AppliedTypeTest
+    given AppliedTypeTest as TypeTest[Tree, Applied] = AppliedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Applied]` */
-    protected val AppliedTypeTest: TypeTest[Tree, Applied]
+    /** Implementation of `AppliedTypeTest` */
+    protected val AppliedTypeTestImpl: TypeTest[Tree, Applied]
 
     /** Module object of `type Applied`  */
     val Applied: AppliedModule
@@ -1750,10 +1750,10 @@ 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 TypeTest[Tree, Annotated] = AnnotatedTypeTest
+    given AnnotatedTypeTest as TypeTest[Tree, Annotated] = AnnotatedTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Annotated]` */
-    protected val AnnotatedTypeTest: TypeTest[Tree, Annotated]
+    /** Implementation of `AnnotatedTypeTest` */
+    protected val AnnotatedTypeTestImpl: TypeTest[Tree, Annotated]
 
     /** Module object of `type Annotated`  */
     val Annotated: AnnotatedModule
@@ -1783,10 +1783,10 @@ 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 TypeTest[Tree, MatchTypeTree] = MatchTypeTreeTypeTest
+    given MatchTypeTreeTypeTest as TypeTest[Tree, MatchTypeTree] = MatchTypeTreeTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, MatchTypeTree]` */
-    protected val MatchTypeTreeTypeTest: TypeTest[Tree, MatchTypeTree]
+    /** Implementation of `MatchTypeTreeTypeTest` */
+    protected val MatchTypeTreeTypeTestImpl: TypeTest[Tree, MatchTypeTree]
 
     /** Module object of `type MatchTypeTree`  */
     val MatchTypeTree: MatchTypeTreeModule
@@ -1817,10 +1817,10 @@ 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 TypeTest[Tree, ByName] = ByNameTypeTest
+    given ByNameTypeTest as TypeTest[Tree, ByName] = ByNameTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, ByName]` */
-    protected val ByNameTypeTest: TypeTest[Tree, ByName]
+    /** Implementation of `ByNameTypeTest` */
+    protected val ByNameTypeTestImpl: TypeTest[Tree, ByName]
 
     /** Module object of `type ByName`  */
     val ByName: ByNameModule
@@ -1849,10 +1849,10 @@ 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 TypeTest[Tree, LambdaTypeTree] = LambdaTypeTreeTypeTest
+    given LambdaTypeTreeTypeTest as TypeTest[Tree, LambdaTypeTree] = LambdaTypeTreeTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, LambdaTypeTree]` */
-    protected val LambdaTypeTreeTypeTest: TypeTest[Tree, LambdaTypeTree]
+    /** Implementation of `LambdaTypeTreeTypeTest` */
+    protected val LambdaTypeTreeTypeTestImpl: TypeTest[Tree, LambdaTypeTree]
 
     /** Module object of `type LambdaTypeTree`  */
     val LambdaTypeTree: LambdaTypeTreeModule
@@ -1882,10 +1882,10 @@ 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 TypeTest[Tree, TypeBind] = TypeBindTypeTest
+    given TypeBindTypeTest as TypeTest[Tree, TypeBind] = TypeBindTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeBind]` */
-    protected val TypeBindTypeTest: TypeTest[Tree, TypeBind]
+    /** Implementation of `TypeBindTypeTest` */
+    protected val TypeBindTypeTestImpl: TypeTest[Tree, TypeBind]
 
     /** Module object of `type TypeBind`  */
     val TypeBind: TypeBindModule
@@ -1915,10 +1915,10 @@ 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 TypeTest[Tree, TypeBlock] = TypeBlockTypeTest
+    given TypeBlockTypeTest as TypeTest[Tree, TypeBlock] = TypeBlockTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeBlock]` */
-    protected val TypeBlockTypeTest: TypeTest[Tree, TypeBlock]
+    /** Implementation of `TypeBlockTypeTest` */
+    protected val TypeBlockTypeTestImpl: TypeTest[Tree, TypeBlock]
 
     /** Module object of `type TypeBlock`  */
     val TypeBlock: TypeBlockModule
@@ -1950,10 +1950,10 @@ 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 TypeTest[Tree, TypeBoundsTree] = TypeBoundsTreeTypeTest
+    given TypeBoundsTreeTypeTest as TypeTest[Tree, TypeBoundsTree] = TypeBoundsTreeTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeBoundsTree]` */
-    protected val TypeBoundsTreeTypeTest: TypeTest[Tree, TypeBoundsTree]
+    /** Implementation of `TypeBoundsTreeTypeTest` */
+    protected val TypeBoundsTreeTypeTestImpl: TypeTest[Tree, TypeBoundsTree]
 
     /** Module object of `type TypeBoundsTree`  */
     val TypeBoundsTree: TypeBoundsTreeModule
@@ -1987,10 +1987,10 @@ 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 TypeTest[Tree, WildcardTypeTree] = WildcardTypeTreeTypeTest
+    given WildcardTypeTreeTypeTest as TypeTest[Tree, WildcardTypeTree] = WildcardTypeTreeTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, WildcardTypeTree]` */
-    protected val WildcardTypeTreeTypeTest: TypeTest[Tree, WildcardTypeTree]
+    /** Implementation of `WildcardTypeTreeTypeTest` */
+    protected val WildcardTypeTreeTypeTestImpl: TypeTest[Tree, WildcardTypeTree]
 
     /** Module object of `type WildcardTypeTree`  */
     val WildcardTypeTree: WildcardTypeTreeModule
@@ -2021,10 +2021,10 @@ 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 TypeTest[Tree, CaseDef] = CaseDefTypeTest
+    given CaseDefTypeTest as TypeTest[Tree, CaseDef] = CaseDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, CaseDef]` */
-    protected val CaseDefTypeTest: TypeTest[Tree, CaseDef]
+    /** Implementation of `CaseDefTypeTest` */
+    protected val CaseDefTypeTestImpl: TypeTest[Tree, CaseDef]
 
     /** Module object of `type CaseDef`  */
     val CaseDef: CaseDefModule
@@ -2055,10 +2055,10 @@ 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 TypeTest[Tree, TypeCaseDef] = TypeCaseDefTypeTest
+    given TypeCaseDefTypeTest as TypeTest[Tree, TypeCaseDef] = TypeCaseDefTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, TypeCaseDef]` */
-    protected val TypeCaseDefTypeTest: TypeTest[Tree, TypeCaseDef]
+    /** Implementation of `TypeCaseDefTypeTest` */
+    protected val TypeCaseDefTypeTestImpl: TypeTest[Tree, TypeCaseDef]
 
     /** Module object of `type TypeCaseDef`  */
     val TypeCaseDef: TypeCaseDefModule
@@ -2090,10 +2090,10 @@ 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 TypeTest[Tree, Bind] = BindTypeTest
+    given BindTypeTest as TypeTest[Tree, Bind] = BindTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Bind]` */
-    protected val BindTypeTest: TypeTest[Tree, Bind]
+    /** Implementation of `BindTypeTest` */
+    protected val BindTypeTestImpl: TypeTest[Tree, Bind]
 
     /** Module object of `type Bind`  */
     val Bind: BindModule
@@ -2123,10 +2123,10 @@ 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 TypeTest[Tree, Unapply] = UnapplyTypeTest
+    given UnapplyTypeTest as TypeTest[Tree, Unapply] = UnapplyTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Unapply]` */
-    protected val UnapplyTypeTest: TypeTest[Tree, Unapply]
+    /** Implementation of `UnapplyTypeTest` */
+    protected val UnapplyTypeTestImpl: TypeTest[Tree, Unapply]
 
     /** Module object of `type Unapply`  */
     val Unapply: UnapplyModule
@@ -2157,10 +2157,10 @@ 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 TypeTest[Tree, Alternatives] = AlternativesTypeTest
+    given AlternativesTypeTest as TypeTest[Tree, Alternatives] = AlternativesTypeTestImpl
 
-    /** Implementation of `TypeTest[Tree, Alternatives]` */
-    protected val AlternativesTypeTest: TypeTest[Tree, Alternatives]
+    /** Implementation of `AlternativesTypeTest` */
+    protected val AlternativesTypeTestImpl: TypeTest[Tree, Alternatives]
 
     /** Module object of `type Alternatives`  */
     val Alternatives: AlternativesModule
@@ -2207,10 +2207,10 @@ 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 TypeTest[ImportSelector, SimpleSelector] = SimpleSelectorTypeTest
+    given SimpleSelectorTypeTest as TypeTest[ImportSelector, SimpleSelector] = SimpleSelectorTypeTestImpl
 
-    /** Implementation of `TypeTest[ImportSelector, SimpleSelector]` */
-    protected val SimpleSelectorTypeTest: TypeTest[ImportSelector, SimpleSelector]
+    /** Implementation of `SimpleSelectorTypeTest` */
+    protected val SimpleSelectorTypeTestImpl: TypeTest[ImportSelector, SimpleSelector]
 
     /** Module object of `type SimpleSelector`  */
     val SimpleSelector: SimpleSelectorModule
@@ -2238,10 +2238,10 @@ 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 TypeTest[ImportSelector, RenameSelector] = RenameSelectorTypeTest
+    given RenameSelectorTypeTest as TypeTest[ImportSelector, RenameSelector] = RenameSelectorTypeTestImpl
 
-    /** Implementation of `TypeTest[ImportSelector, RenameSelector]` */
-    protected val RenameSelectorTypeTest: TypeTest[ImportSelector, RenameSelector]
+    /** Implementation of `RenameSelectorTypeTest` */
+    protected val RenameSelectorTypeTestImpl: TypeTest[ImportSelector, RenameSelector]
 
     /** Module object of `type RenameSelector`  */
     val RenameSelector: RenameSelectorModule
@@ -2271,10 +2271,10 @@ 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 TypeTest[ImportSelector, OmitSelector] = OmitSelectorTypeTest
+    given OmitSelectorTypeTest as TypeTest[ImportSelector, OmitSelector] = OmitSelectorTypeTestImpl
 
-    /** Implementation of `TypeTest[ImportSelector, OmitSelector]` */
-    protected val OmitSelectorTypeTest: TypeTest[ImportSelector, OmitSelector]
+    /** Implementation of `OmitSelectorTypeTest` */
+    protected val OmitSelectorTypeTestImpl: TypeTest[ImportSelector, OmitSelector]
 
     /** Module object of `type OmitSelector`  */
     val OmitSelector: OmitSelectorModule
@@ -2301,10 +2301,10 @@ 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 TypeTest[ImportSelector, GivenSelector] = GivenSelectorTypeTest
+    given GivenSelectorTypeTest as TypeTest[ImportSelector, GivenSelector] = GivenSelectorTypeTestImpl
 
-    /** Implementation of `TypeTest[ImportSelector, GivenSelector]` */
-    protected val GivenSelectorTypeTest: TypeTest[ImportSelector, GivenSelector]
+    /** Implementation of `GivenSelectorTypeTest` */
+    protected val GivenSelectorTypeTestImpl: TypeTest[ImportSelector, GivenSelector]
 
     /** Module object of `type GivenSelector`  */
     val GivenSelector: GivenSelectorModule
@@ -2479,10 +2479,10 @@ 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 TypeTest[TypeRepr, ConstantType] = ConstantTypeTypeTest
+    given ConstantTypeTypeTest as TypeTest[TypeRepr, ConstantType] = ConstantTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, ConstantType]` */
-    protected val ConstantTypeTypeTest: TypeTest[TypeRepr, ConstantType]
+    /** Implementation of `ConstantTypeTypeTest` */
+    protected val ConstantTypeTypeTestImpl: TypeTest[TypeRepr, ConstantType]
 
     /** Module object of `type ConstantType`  */
     val ConstantType: ConstantTypeModule
@@ -2510,10 +2510,10 @@ 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 TypeTest[TypeRepr, TermRef] = TermRefTypeTest
+    given TermRefTypeTest as TypeTest[TypeRepr, TermRef] = TermRefTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, TermRef]` */
-    protected val TermRefTypeTest: TypeTest[TypeRepr, TermRef]
+    /** Implementation of `TermRefTypeTest` */
+    protected val TermRefTypeTestImpl: TypeTest[TypeRepr, TermRef]
 
     /** Module object of `type TermRef`  */
     val TermRef: TermRefModule
@@ -2542,10 +2542,10 @@ 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 TypeTest[TypeRepr, TypeRef] = TypeRefTypeTest
+    given TypeRefTypeTest as TypeTest[TypeRepr, TypeRef] = TypeRefTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, TypeRef]` */
-    protected val TypeRefTypeTest: TypeTest[TypeRepr, TypeRef]
+    /** Implementation of `TypeRefTypeTest` */
+    protected val TypeRefTypeTestImpl: TypeTest[TypeRepr, TypeRef]
 
     /** Module object of `type TypeRef`  */
     val TypeRef: TypeRefModule
@@ -2575,10 +2575,10 @@ 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 TypeTest[TypeRepr, SuperType] = SuperTypeTypeTest
+    given SuperTypeTypeTest as TypeTest[TypeRepr, SuperType] = SuperTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, SuperType]` */
-    protected val SuperTypeTypeTest: TypeTest[TypeRepr, SuperType]
+    /** Implementation of `SuperTypeTypeTest` */
+    protected val SuperTypeTypeTestImpl: TypeTest[TypeRepr, SuperType]
 
     /** Module object of `type SuperType`  */
     val SuperType: SuperTypeModule
@@ -2607,10 +2607,10 @@ 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 TypeTest[TypeRepr, Refinement] = RefinementTypeTest
+    given RefinementTypeTest as TypeTest[TypeRepr, Refinement] = RefinementTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, Refinement]` */
-    protected val RefinementTypeTest: TypeTest[TypeRepr, Refinement]
+    /** Implementation of `RefinementTypeTest` */
+    protected val RefinementTypeTestImpl: TypeTest[TypeRepr, Refinement]
 
     /** Module object of `type Refinement`  */
     val Refinement: RefinementModule
@@ -2640,10 +2640,10 @@ 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 TypeTest[TypeRepr, AppliedType] = AppliedTypeTypeTest
+    given AppliedTypeTypeTest as TypeTest[TypeRepr, AppliedType] = AppliedTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, AppliedType]` */
-    protected val AppliedTypeTypeTest: TypeTest[TypeRepr, AppliedType]
+    /** Implementation of `AppliedTypeTypeTest` */
+    protected val AppliedTypeTypeTestImpl: TypeTest[TypeRepr, AppliedType]
 
     /** Module object of `type AppliedType`  */
     val AppliedType: AppliedTypeModule
@@ -2671,10 +2671,10 @@ 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 TypeTest[TypeRepr, AnnotatedType] = AnnotatedTypeTypeTest
+    given AnnotatedTypeTypeTest as TypeTest[TypeRepr, AnnotatedType] = AnnotatedTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, AnnotatedType]` */
-    protected val AnnotatedTypeTypeTest: TypeTest[TypeRepr, AnnotatedType]
+    /** Implementation of `AnnotatedTypeTypeTest` */
+    protected val AnnotatedTypeTypeTestImpl: TypeTest[TypeRepr, AnnotatedType]
 
     /** Module object of `type AnnotatedType`  */
     val AnnotatedType: AnnotatedTypeModule
@@ -2703,10 +2703,10 @@ 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 TypeTest[TypeRepr, AndType] = AndTypeTypeTest
+    given AndTypeTypeTest as TypeTest[TypeRepr, AndType] = AndTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, AndType]` */
-    protected val AndTypeTypeTest: TypeTest[TypeRepr, AndType]
+    /** Implementation of `AndTypeTypeTest` */
+    protected val AndTypeTypeTestImpl: TypeTest[TypeRepr, AndType]
 
     /** Module object of `type AndType`  */
     val AndType: AndTypeModule
@@ -2735,10 +2735,10 @@ 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 TypeTest[TypeRepr, OrType] = OrTypeTypeTest
+    given OrTypeTypeTest as TypeTest[TypeRepr, OrType] = OrTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, OrType]` */
-    protected val OrTypeTypeTest: TypeTest[TypeRepr, OrType]
+    /** Implementation of `OrTypeTypeTest` */
+    protected val OrTypeTypeTestImpl: TypeTest[TypeRepr, OrType]
 
     /** Module object of `type OrType`  */
     val OrType: OrTypeModule
@@ -2767,10 +2767,10 @@ 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 TypeTest[TypeRepr, MatchType] = MatchTypeTypeTest
+    given MatchTypeTypeTest as TypeTest[TypeRepr, MatchType] = MatchTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, MatchType]` */
-    protected val MatchTypeTypeTest: TypeTest[TypeRepr, MatchType]
+    /** Implementation of `MatchTypeTypeTest` */
+    protected val MatchTypeTypeTestImpl: TypeTest[TypeRepr, MatchType]
 
     /** Module object of `type MatchType`  */
     val MatchType: MatchTypeModule
@@ -2800,10 +2800,10 @@ 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 TypeTest[TypeRepr, ByNameType] = ByNameTypeTypeTest
+    given ByNameTypeTypeTest as TypeTest[TypeRepr, ByNameType] = ByNameTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, ByNameType]` */
-    protected val ByNameTypeTypeTest: TypeTest[TypeRepr, ByNameType]
+    /** Implementation of `ByNameTypeTypeTest` */
+    protected val ByNameTypeTypeTestImpl: TypeTest[TypeRepr, ByNameType]
 
     /** Module object of `type ByNameType`  */
     val ByNameType: ByNameTypeModule
@@ -2831,10 +2831,10 @@ 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 TypeTest[TypeRepr, ParamRef] = ParamRefTypeTest
+    given ParamRefTypeTest as TypeTest[TypeRepr, ParamRef] = ParamRefTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, ParamRef]` */
-    protected val ParamRefTypeTest: TypeTest[TypeRepr, ParamRef]
+    /** Implementation of `ParamRefTypeTest` */
+    protected val ParamRefTypeTestImpl: TypeTest[TypeRepr, ParamRef]
 
     /** Module object of `type ParamRef`  */
     val ParamRef: ParamRefModule
@@ -2862,10 +2862,10 @@ 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 TypeTest[TypeRepr, ThisType] = ThisTypeTypeTest
+    given ThisTypeTypeTest as TypeTest[TypeRepr, ThisType] = ThisTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, ThisType]` */
-    protected val ThisTypeTypeTest: TypeTest[TypeRepr, ThisType]
+    /** Implementation of `ThisTypeTypeTest` */
+    protected val ThisTypeTypeTestImpl: TypeTest[TypeRepr, ThisType]
 
     /** Module object of `type ThisType`  */
     val ThisType: ThisTypeModule
@@ -2892,10 +2892,10 @@ 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 TypeTest[TypeRepr, RecursiveThis] = RecursiveThisTypeTest
+    given RecursiveThisTypeTest as TypeTest[TypeRepr, RecursiveThis] = RecursiveThisTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, RecursiveThis]` */
-    protected val RecursiveThisTypeTest: TypeTest[TypeRepr, RecursiveThis]
+    /** Implementation of `RecursiveThisTypeTest` */
+    protected val RecursiveThisTypeTestImpl: TypeTest[TypeRepr, RecursiveThis]
 
     /** Module object of `type RecursiveThis`  */
     val RecursiveThis: RecursiveThisModule
@@ -2922,10 +2922,10 @@ 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 TypeTest[TypeRepr, RecursiveType] = RecursiveTypeTypeTest
+    given RecursiveTypeTypeTest as TypeTest[TypeRepr, RecursiveType] = RecursiveTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, RecursiveType]` */
-    protected val RecursiveTypeTypeTest: TypeTest[TypeRepr, RecursiveType]
+    /** Implementation of `RecursiveTypeTypeTest` */
+    protected val RecursiveTypeTypeTestImpl: TypeTest[TypeRepr, RecursiveType]
 
     /** Module object of `type RecursiveType`  */
     val RecursiveType: RecursiveTypeModule
@@ -2968,10 +2968,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type MethodType <: LambdaType
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `MethodType` */
-    given TypeTest[TypeRepr, MethodType] = MethodTypeTypeTest
+    given MethodTypeTypeTest as TypeTest[TypeRepr, MethodType] = MethodTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, MethodType]` */
-    protected val MethodTypeTypeTest: TypeTest[TypeRepr, MethodType]
+    /** Implementation of `MethodTypeTypeTest` */
+    protected val MethodTypeTypeTestImpl: TypeTest[TypeRepr, MethodType]
 
     /** Module object of `type MethodType`  */
     val MethodType: MethodTypeModule
@@ -3004,10 +3004,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type PolyType <: LambdaType
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `PolyType` */
-    given TypeTest[TypeRepr, PolyType] = PolyTypeTypeTest
+    given PolyTypeTypeTest as TypeTest[TypeRepr, PolyType] = PolyTypeTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, PolyType]` */
-    protected val PolyTypeTypeTest: TypeTest[TypeRepr, PolyType]
+    /** Implementation of `PolyTypeTypeTest` */
+    protected val PolyTypeTypeTestImpl: TypeTest[TypeRepr, PolyType]
 
     /** Module object of `type PolyType`  */
     val PolyType: PolyTypeModule
@@ -3038,10 +3038,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     type TypeLambda <: LambdaType
 
     /** `TypeTest` that allows testing at runtime in a pattern match if a `TypeRepr` is a `TypeLambda` */
-    given TypeTest[TypeRepr, TypeLambda] = TypeLambdaTypeTest
+    given TypeLambdaTypeTest as TypeTest[TypeRepr, TypeLambda] = TypeLambdaTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, TypeLambda]` */
-    protected val TypeLambdaTypeTest: TypeTest[TypeRepr, TypeLambda]
+    /** Implementation of `TypeLambdaTypeTest` */
+    protected val TypeLambdaTypeTestImpl: TypeTest[TypeRepr, TypeLambda]
 
     /** Module object of `type TypeLambda`  */
     val TypeLambda: TypeLambdaModule
@@ -3074,10 +3074,10 @@ 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 TypeTest[TypeRepr, TypeBounds] = TypeBoundsTypeTest
+    given TypeBoundsTypeTest as TypeTest[TypeRepr, TypeBounds] = TypeBoundsTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, TypeBounds]` */
-    protected val TypeBoundsTypeTest: TypeTest[TypeRepr, TypeBounds]
+    /** Implementation of `TypeBoundsTypeTest` */
+    protected val TypeBoundsTypeTestImpl: TypeTest[TypeRepr, TypeBounds]
 
     /** Module object of `type TypeBounds`  */
     val TypeBounds: TypeBoundsModule
@@ -3111,10 +3111,10 @@ 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 TypeTest[TypeRepr, NoPrefix] = NoPrefixTypeTest
+    given NoPrefixTypeTest as TypeTest[TypeRepr, NoPrefix] = NoPrefixTypeTestImpl
 
-    /** Implementation of `TypeTest[TypeRepr, NoPrefix]` */
-    protected val NoPrefixTypeTest: TypeTest[TypeRepr, NoPrefix]
+    /** Implementation of `NoPrefixTypeTest` */
+    protected val NoPrefixTypeTestImpl: TypeTest[TypeRepr, NoPrefix]
 
     /** Module object of `type NoPrefix`  */
     val NoPrefix: NoPrefixModule
@@ -3322,10 +3322,10 @@ 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 TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTest
+    given ImplicitSearchSuccessTypeTest as TypeTest[ImplicitSearchResult, ImplicitSearchSuccess] = ImplicitSearchSuccessTypeTestImpl
 
-    /** Implementation of `TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]` */
-    protected val ImplicitSearchSuccessTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]
+    /** Implementation of `ImplicitSearchSuccessTypeTest` */
+    protected val ImplicitSearchSuccessTypeTestImpl: TypeTest[ImplicitSearchResult, ImplicitSearchSuccess]
 
     type ImplicitSearchSuccess <: ImplicitSearchResult
 
@@ -3345,10 +3345,10 @@ 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 TypeTest[ImplicitSearchResult, ImplicitSearchFailure] = ImplicitSearchFailureTypeTest
+    given ImplicitSearchFailureTypeTest as TypeTest[ImplicitSearchResult, ImplicitSearchFailure] = ImplicitSearchFailureTypeTestImpl
 
-    /** Implementation of `TypeTest[ImplicitSearchResult, ImplicitSearchFailure]` */
-    protected val ImplicitSearchFailureTypeTest: TypeTest[ImplicitSearchResult, ImplicitSearchFailure]
+    /** Implementation of `ImplicitSearchFailureTypeTest` */
+    protected val ImplicitSearchFailureTypeTestImpl: TypeTest[ImplicitSearchResult, ImplicitSearchFailure]
 
     /** Makes extension methods on `ImplicitSearchFailure` available without any imports */
     given ImplicitSearchFailureMethods as ImplicitSearchFailureMethods = ImplicitSearchFailureMethodsImpl
@@ -3366,26 +3366,26 @@ 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 TypeTest[ImplicitSearchResult, DivergingImplicit] = DivergingImplicitTypeTest
+    given DivergingImplicitTypeTest as TypeTest[ImplicitSearchResult, DivergingImplicit] = DivergingImplicitTypeTestImpl
 
-    /** Implementation of `TypeTest[ImplicitSearchResult, DivergingImplicit]` */
-    protected val DivergingImplicitTypeTest: TypeTest[ImplicitSearchResult, DivergingImplicit]
+    /** Implementation of `DivergingImplicitTypeTest` */
+    protected val DivergingImplicitTypeTestImpl: TypeTest[ImplicitSearchResult, DivergingImplicit]
 
     type NoMatchingImplicits <: ImplicitSearchFailure
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is a `NoMatchingImplicits` */
-    given TypeTest[ImplicitSearchResult, NoMatchingImplicits] = NoMatchingImplicitsTypeTest
+    given NoMatchingImplicitsTypeTest as TypeTest[ImplicitSearchResult, NoMatchingImplicits] = NoMatchingImplicitsTypeTestImpl
 
-    /** Implementation of `TypeTest[ImplicitSearchResult, NoMatchingImplicits]` */
-    protected val NoMatchingImplicitsTypeTest: TypeTest[ImplicitSearchResult, NoMatchingImplicits]
+    /** Implementation of `NoMatchingImplicitsTypeTest` */
+    protected val NoMatchingImplicitsTypeTestImpl: TypeTest[ImplicitSearchResult, NoMatchingImplicits]
 
     type AmbiguousImplicits <: ImplicitSearchFailure
 
     /** `TypeTest` that allows testing at runtime in a pattern match if an `ImplicitSearchResult` is an `AmbiguousImplicits` */
-    given TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTest
+    given AmbiguousImplicitsTypeTest as TypeTest[ImplicitSearchResult, AmbiguousImplicits] = AmbiguousImplicitsTypeTestImpl
 
-    /** Implementation of `TypeTest[ImplicitSearchResult, AmbiguousImplicits]` */
-    protected val AmbiguousImplicitsTypeTest: TypeTest[ImplicitSearchResult, AmbiguousImplicits]
+    /** Implementation of `AmbiguousImplicitsTypeTest` */
+    protected val AmbiguousImplicitsTypeTestImpl: TypeTest[ImplicitSearchResult, AmbiguousImplicits]
 
     /////////////
     // SYMBOLS //