diff --git a/community-build/community-projects/scalatest b/community-build/community-projects/scalatest
index 41b745c72861..0fbb5bf00de5 160000
--- a/community-build/community-projects/scalatest
+++ b/community-build/community-projects/scalatest
@@ -1 +1 @@
-Subproject commit 41b745c72861e25fd0bcba03d2cfaf9237096050
+Subproject commit 0fbb5bf00de5af7cb63ae98987baff48bfd0c673
diff --git a/community-build/community-projects/shapeless b/community-build/community-projects/shapeless
index 62157bc8c67c..dcf630b34913 160000
--- a/community-build/community-projects/shapeless
+++ b/community-build/community-projects/shapeless
@@ -1 +1 @@
-Subproject commit 62157bc8c67c887d0f38ca2af3e06c9dbd99dd1e
+Subproject commit dcf630b349135d189d5fa0b124911b917ee1d754
diff --git a/community-build/community-projects/utest b/community-build/community-projects/utest
index b0b565e1be62..5a539e41507a 160000
--- a/community-build/community-projects/utest
+++ b/community-build/community-projects/utest
@@ -1 +1 @@
-Subproject commit b0b565e1be6211f2f75b7fe7f1c025f973ab7c40
+Subproject commit 5a539e41507a93d9255f1954bde78edd1cd7561f
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 52a0d4b3ceef..38df3789e64b 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -160,7 +160,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** Is tree a variable pattern? */
   def isVarPattern(pat: Tree): Boolean = unsplice(pat) match {
-    case x: Ident => x.name.isVariableName && !isBackquoted(x)
+    case x: Ident => x.name.isVarPattern && !isBackquoted(x)
     case _  => false
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/NameKinds.scala b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
index 28791b168aeb..10e0fef7c2e1 100644
--- a/compiler/src/dotty/tools/dotc/core/NameKinds.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
@@ -320,6 +320,7 @@ object NameKinds {
   val PatMatStdBinderName: UniqueNameKind    = new UniqueNameKind("x")
   val PatMatAltsName: UniqueNameKind         = new UniqueNameKind("matchAlts")
   val PatMatResultName: UniqueNameKind       = new UniqueNameKind("matchResult")
+  val PatMatVarName: UniqueNameKind          = new UniqueNameKind("ev$")
 
   val LocalOptInlineLocalObj: UniqueNameKind = new UniqueNameKind("ilo")
 
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index 0436c4ae74af..15afb7a69576 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -79,16 +79,17 @@ object NameOps {
       case name: SimpleName => name.exists(isOperatorPart)
       case _ => false
 
-    /** Is name a variable name? */
-    def isVariableName: Boolean = testSimple { n =>
-      n.length > 0 && {
-        val first = n.head
-        (((first.isLower && first.isLetter) || first == '_')
-          && (n != false_)
-          && (n != true_)
-          && (n != null_))
-      }
-    }
+    /** Is name of a variable pattern? */
+    def isVarPattern: Boolean =
+      testSimple { n =>
+        n.length > 0 && {
+          val first = n.head
+          (((first.isLower && first.isLetter) || first == '_')
+            && (n != false_)
+            && (n != true_)
+            && (n != null_))
+        }
+      } || name.is(PatMatVarName)
 
     def isOpAssignmentName: Boolean = name match {
       case raw.NE | raw.LE | raw.GE | EMPTY =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 99a2a82a35af..ef02100ac55f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2594,7 +2594,7 @@ object Parsers {
         val givenMod = atSpan(in.skipToken())(Mod.Given())
         atSpan(in.offset) {
           in.token match {
-            case IDENTIFIER | USCORE if in.name.isVariableName =>
+            case IDENTIFIER | USCORE if in.name.isVarPattern =>
               val name = in.name
               in.nextToken()
               accept(COLON)
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 012f694f7ee0..455b8c205619 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -194,7 +194,7 @@ object PatternMatcher {
         case Typed(_, tpt) if tpt.tpe.isRepeatedParam => true
         case Bind(nme.WILDCARD, WildcardPattern()) => true // don't skip when binding an interesting symbol!
         case t if isWildcardArg(t)                 => true
-        case x: Ident                              => x.name.isVariableName && !isBackquoted(x)
+        case x: Ident                              => x.name.isVarPattern && !isBackquoted(x)
         case Alternative(ps)                       => ps.forall(unapply)
         case EmptyTree                             => true
         case _                                     => false
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 11fb10863cda..d96a986b396b 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -9,7 +9,7 @@ import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.NameKinds.UniqueName
+import dotty.tools.dotc.core.NameKinds.{UniqueName, PatMatVarName}
 import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.core.StdNames._
@@ -156,11 +156,13 @@ trait QuotesAndSplices {
     if ctx.mode.is(Mode.QuotedPattern) && level == 1 then
       def spliceOwner(ctx: Context): Symbol =
       if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
-      val name = tree.expr match {
-        case Ident(name) => ("$" + name).toTypeName
+      val (name, expr) = tree.expr match {
+        case Ident(name) =>
+          val nameOfSyntheticGiven = PatMatVarName.fresh()
+          (name.toTypeName, untpd.cpy.Ident(tree.expr)(nameOfSyntheticGiven))
         case expr =>
           report.error("expected a name binding", expr.srcPos)
-          "$error".toTypeName
+          ("$error".toTypeName, expr)
       }
 
       val typeSymInfo = pt match
@@ -168,7 +170,7 @@ trait QuotesAndSplices {
         case _ => TypeBounds.empty
       val typeSym = newSymbol(spliceOwner(ctx), name, EmptyFlags, typeSymInfo, NoSymbol, tree.expr.span)
       typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuotedPatterns_patternTypeAnnot.typeRef)).withSpan(tree.expr.span)))
-      val pat = typedPattern(tree.expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
+      val pat = typedPattern(expr, defn.QuotedTypeClass.typeRef.appliedTo(typeSym.typeRef))(
           using spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
       pat.select(tpnme.spliceType)
     else
@@ -214,7 +216,7 @@ trait QuotesAndSplices {
     def getBinding(sym: Symbol): Bind =
       typeBindings.getOrElseUpdate(sym, {
         val bindingBounds = sym.info
-        val bsym = newPatternBoundSymbol(sym.name.toTypeName, bindingBounds, quoted.span)
+        val bsym = newPatternBoundSymbol(sym.name.toString.stripPrefix("$").toTypeName, bindingBounds, quoted.span)
         Bind(bsym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(quoted.span)
       })
 
@@ -263,13 +265,14 @@ trait QuotesAndSplices {
           val sym = tree.tpe.dealias.typeSymbol
           if sym.exists then
             val tdef = TypeDef(sym.asType).withSpan(sym.span)
-            freshTypeBindingsBuff += transformTypeBindingTypeDef(tdef, freshTypePatBuf)
+            val nameOfSyntheticGiven = pat.symbol.name.toTermName
+            freshTypeBindingsBuff += transformTypeBindingTypeDef(nameOfSyntheticGiven, tdef, freshTypePatBuf)
             TypeTree(tree.tpe.dealias).withSpan(tree.span)
           else
             tree
         case tdef: TypeDef  =>
           if tdef.symbol.hasAnnotation(defn.InternalQuotedPatterns_patternTypeAnnot) then
-            transformTypeBindingTypeDef(tdef, typePatBuf)
+            transformTypeBindingTypeDef(PatMatVarName.fresh(), tdef, typePatBuf)
           else if tdef.symbol.isClass then
             val kind = if tdef.symbol.is(Module) then "objects" else "classes"
             report.error("Implementation restriction: cannot match " + kind, tree.srcPos)
@@ -305,13 +308,12 @@ trait QuotesAndSplices {
           super.transform(tree)
       }
 
-      private def transformTypeBindingTypeDef(tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]])(using Context): Tree = {
+      private def transformTypeBindingTypeDef(nameOfSyntheticGiven: TermName, tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]])(using Context): Tree = {
         if (variance == -1)
           tdef.symbol.addAnnotation(Annotation(New(ref(defn.InternalQuotedPatterns_fromAboveAnnot.typeRef)).withSpan(tdef.span)))
         val bindingType = getBinding(tdef.symbol).symbol.typeRef
         val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
-        val bindName = tdef.name.toString.stripPrefix("$").toTermName
-        val sym = newPatternBoundSymbol(bindName, bindingTypeTpe, tdef.span, flags = ImplicitTerm)(using ctx0)
+        val sym = newPatternBoundSymbol(nameOfSyntheticGiven, bindingTypeTpe, tdef.span, flags = ImplicitTerm)(using ctx0)
         buff += Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingTypeTpe)).withSpan(tdef.span)
         super.transform(tdef)
       }
diff --git a/tests/neg-macros/quotedPatterns-5.scala b/tests/neg-macros/quotedPatterns-5.scala
index abdb2edc5670..3638b21e4724 100644
--- a/tests/neg-macros/quotedPatterns-5.scala
+++ b/tests/neg-macros/quotedPatterns-5.scala
@@ -1,10 +1,10 @@
 import scala.quoted._
 object Test {
-  def test(x: quoted.Expr[Int])(using QuoteContext) = x match {
-    case '{ type $t; poly[$t]($x); 4 } => ??? // error: duplicate pattern variable: $t
-    case '{ type `$t`; poly[`$t`]($x); 4 } =>
-      val tt: quoted.Type[_] = t // error
-      ???
+  def test(x: quoted.Expr[Int])(using QuoteContext): Unit = x match {
+    case '{ type $T; 4 } => Type[T]
+    case '{ type $T; poly[$T]($x); 4 } => // error: duplicate pattern variable: T
+    case '{ type `$T`; poly[`$T`]($x); 4 } =>
+      Type[T] // error
     case _ =>
   }
 
diff --git a/tests/pos-macros/i6997c.scala b/tests/pos-macros/i6997c.scala
index 8be7ca309ef6..2d3a56bfb496 100644
--- a/tests/pos-macros/i6997c.scala
+++ b/tests/pos-macros/i6997c.scala
@@ -6,9 +6,9 @@ inline def mcr(x: => Any): Any = ${mcrImpl('x)}
 
 def mcrImpl(body: Expr[Any])(using ctx: QuoteContext): Expr[Any] =
   body match
-    case '{$x: $t} =>
+    case '{$x: $T} =>
       '{
-        val tmp: $t = $x
+        val tmp: T = $x
         println(tmp)
         tmp
       }
diff --git a/tests/pos-macros/i7264.scala b/tests/pos-macros/i7264.scala
index 0467b0714dea..1b6e88c669be 100644
--- a/tests/pos-macros/i7264.scala
+++ b/tests/pos-macros/i7264.scala
@@ -1,7 +1,7 @@
 import scala.quoted._
 class Foo {
   def f[T2](t: Type[T2])(using QuoteContext) = t match {
-    case '[ *:[Int, $t] ] =>
-      '[ *:[Int, $t] ]
+    case '[ *:[Int, $T] ] =>
+      '[ *:[Int, T] ]
   }
 }
\ No newline at end of file
diff --git a/tests/pos-macros/i7264b.scala b/tests/pos-macros/i7264b.scala
index 3c4f0b0a9945..eae0b81ebdd2 100644
--- a/tests/pos-macros/i7264b.scala
+++ b/tests/pos-macros/i7264b.scala
@@ -2,6 +2,6 @@ import scala.quoted._
 class Foo {
   def f[T2: Type](e: Expr[T2])(using QuoteContext) = e match {
     case '{ $x: *:[Int, $t] } =>
-      '[ *:[Int, $t] ]
+      '[ *:[Int, t] ]
   }
 }
diff --git a/tests/pos-macros/i7264c.scala b/tests/pos-macros/i7264c.scala
index d246bbb23027..f98b4d8c04e7 100644
--- a/tests/pos-macros/i7264c.scala
+++ b/tests/pos-macros/i7264c.scala
@@ -1,9 +1,9 @@
 import scala.quoted._
 class Foo {
   def f[T2: Type](e: Expr[T2])(using QuoteContext) = e match {
-    case '{ $x: $t0 } =>
-      t0 match
-        case '[ *:[Int, $t] ] =>
-          '[ *:[Int, $t] ]
+    case '{ $x: $T0 } =>
+      Type[T0] match
+        case '[ *:[Int, $T] ] =>
+          '[ *:[Int, T] ]
   }
 }
diff --git a/tests/pos-macros/tasty-constant-type/Macro_1.scala b/tests/pos-macros/tasty-constant-type/Macro_1.scala
index 17986fcc9936..51738c86e059 100644
--- a/tests/pos-macros/tasty-constant-type/Macro_1.scala
+++ b/tests/pos-macros/tasty-constant-type/Macro_1.scala
@@ -4,15 +4,15 @@ object Macro {
 
   trait AddInt[A <: Int, B <: Int] { type Out <: Int }
 
-  transparent inline def ff[A <: Int, B <: Int](): AddInt[A, B] = ${ impl('[A], '[B]) }
+  transparent inline def ff[A <: Int, B <: Int](): AddInt[A, B] = ${ impl[A, B] }
 
-  def impl[A <: Int : Type, B <: Int : Type](a: Type[A], b: Type[B])(using qctx: QuoteContext) : Expr[AddInt[A, B]] = {
+  def impl[A <: Int : Type, B <: Int : Type](using qctx: QuoteContext) : Expr[AddInt[A, B]] = {
     import qctx.reflect._
 
-    val ConstantType(Constant.Int(v1)) = a.unseal.tpe
-    val ConstantType(Constant.Int(v2)) = b.unseal.tpe
+    val ConstantType(Constant.Int(v1)) = Type.of[A]
+    val ConstantType(Constant.Int(v2)) = Type.of[B]
 
     Literal(Constant.Int(v1 + v2)).tpe.seal match
-      case '[$t] => '{ null: AddInt[$a, $b] { type Out = $t } }
+      case '[$T] => '{ null: AddInt[A, B] { type Out = T } }
   }
 }
diff --git a/tests/run-macros/flops-rewrite-3/Macro_1.scala b/tests/run-macros/flops-rewrite-3/Macro_1.scala
index dd6f196ec266..b6ac17ddda22 100644
--- a/tests/run-macros/flops-rewrite-3/Macro_1.scala
+++ b/tests/run-macros/flops-rewrite-3/Macro_1.scala
@@ -59,7 +59,7 @@ class CheckedTransformation(transform: PartialFunction[Expr[Any], Expr[Any]]) ex
   def apply[T: Type](e: Expr[T])(using QuoteContext): Expr[T] = {
     transform.applyOrElse(e, identity) match {
       case '{ $e2: T } => e2
-      case '{ $e2: $t } =>
+      case '{ $e2: $T } =>
         throw new Exception(
           s"""Transformed
             |${e.show}
@@ -69,7 +69,7 @@ class CheckedTransformation(transform: PartialFunction[Expr[Any], Expr[Any]]) ex
             |Expected type to be
             |${summon[Type[T]].show}
             |but was
-            |${t.show}
+            |${Type[T].show}
           """.stripMargin)
     }
   }
diff --git a/tests/run-macros/flops-rewrite/Macro_1.scala b/tests/run-macros/flops-rewrite/Macro_1.scala
index 2722623dac26..69077fae663b 100644
--- a/tests/run-macros/flops-rewrite/Macro_1.scala
+++ b/tests/run-macros/flops-rewrite/Macro_1.scala
@@ -49,7 +49,7 @@ private class Rewriter(preTransform: Expr[Any] => Expr[Any], postTransform: Expr
            |Expected type to be
            |${summon[Type[T]].show}
            |but was
-           |${t.show}
+           |${Type[t].show}
          """.stripMargin)
     }
   }
diff --git a/tests/run-macros/i7987/Macros_1.scala b/tests/run-macros/i7987/Macros_1.scala
index 955f1807d7ca..a68cfbd90f1a 100644
--- a/tests/run-macros/i7987/Macros_1.scala
+++ b/tests/run-macros/i7987/Macros_1.scala
@@ -7,6 +7,6 @@ object Macros {
 
   def macroImpl[T]()(using qctx: QuoteContext): Expr[String] = {
     Expr.summon[Mirror.Of[Some[Int]]] match
-      case Some('{ $_ : $t }) => Expr(t.show)
+      case Some('{ $_ : $T }) => Expr(Type[T].show)
   }
 }
diff --git a/tests/run-macros/i8007/Macro_1.scala b/tests/run-macros/i8007/Macro_1.scala
index 61ebb3490cba..1f118fb56f4c 100644
--- a/tests/run-macros/i8007/Macro_1.scala
+++ b/tests/run-macros/i8007/Macro_1.scala
@@ -4,9 +4,9 @@ import scala.quoted._
 
 object Macro1 {
 
-  def mirrorFields[T](t: Type[T])(using qctx: QuoteContext): List[String] =
-    t match {
-      case '[$field *: $fields] => field.show :: mirrorFields(fields)
+  def mirrorFields[T: Type](using qctx: QuoteContext): List[String] =
+    Type[T] match {
+      case '[$Field *: $Fields] => Type[Field].show :: mirrorFields[Fields]
       case '[EmptyTuple] => Nil
     }
 
@@ -22,8 +22,8 @@ object Macro1 {
     val mirrorTpe = '[Mirror.Of[T]]
 
     Expr.summon(using mirrorTpe).get match {
-      case '{ $m: Mirror.ProductOf[T]{ type MirroredElemLabels = $t } } => {
-        Expr(mirrorFields(t))
+      case '{ $m: Mirror.ProductOf[T]{ type MirroredElemLabels = $Elems } } => {
+        Expr(mirrorFields[Elems])
       }
     }
   }
diff --git a/tests/run-macros/i8007/Macro_2.scala b/tests/run-macros/i8007/Macro_2.scala
index a8de8b4f086d..3f4df0d92e60 100644
--- a/tests/run-macros/i8007/Macro_2.scala
+++ b/tests/run-macros/i8007/Macro_2.scala
@@ -4,9 +4,9 @@ import scala.quoted._
 
 object Macro2 {
 
-  def mirrorFields[T](t: Type[T])(using qctx: QuoteContext): List[String] =
+  def mirrorFields[T](using t: Type[T])(using qctx: QuoteContext): List[String] =
     t match {
-      case '[$field *: $fields] => field.show.substring(1, field.show.length-1) :: mirrorFields(fields)
+      case '[$Field *: $Fields] => Type[Field].show.substring(1, Type[Field].show.length-1) :: mirrorFields[Fields]
       case '[EmptyTuple] => Nil
     }
 
@@ -24,8 +24,8 @@ object Macro2 {
       import qctx.reflect._
 
       val fields = ev match {
-        case '{ $m: Mirror.ProductOf[T] { type MirroredElemLabels = $t } } =>
-          mirrorFields(t)
+        case '{ $m: Mirror.ProductOf[T] { type MirroredElemLabels = $Labels } } =>
+          mirrorFields[Labels]
       }
 
       val body: Expr[T] => Expr[String] = elem =>
diff --git a/tests/run-macros/i8007/Macro_3.scala b/tests/run-macros/i8007/Macro_3.scala
index d562a4ab2517..edf5d8f4c938 100644
--- a/tests/run-macros/i8007/Macro_3.scala
+++ b/tests/run-macros/i8007/Macro_3.scala
@@ -25,10 +25,10 @@ object Eq {
       def eqv(x: T, y: T): Boolean = body(x, y)
     }
 
-  def summonAll[T](t: Type[T])(using qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
-    case '[String *: $tpes] => '{ summon[Eq[String]] }  :: summonAll(tpes)
-    case '[Int *: $tpes]    => '{ summon[Eq[Int]] }     :: summonAll(tpes)
-    case '[$tpe *: $tpes]   => derived(using tpe, qctx) :: summonAll(tpes)
+  def summonAll[T](using t: Type[T])(using qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
+    case '[String *: $Tpes] => '{ summon[Eq[String]] }  :: summonAll[Tpes]
+    case '[Int *: $Tpes]    => '{ summon[Eq[Int]] }     :: summonAll[Tpes]
+    case '[$Tpe *: $Tpes]   => derived[Tpe] :: summonAll[Tpes]
     case '[EmptyTuple] => Nil
   }
 
@@ -38,8 +38,8 @@ object Eq {
     val ev: Expr[Mirror.Of[T]] = Expr.summon(using '[Mirror.Of[T]]).get
 
     ev match {
-      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elementTypes }} =>
-        val elemInstances = summonAll(elementTypes)
+      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $ElementTypes }} =>
+        val elemInstances = summonAll[ElementTypes]
         val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) => {
           elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
             case (acc, (elem, index)) =>
@@ -53,8 +53,8 @@ object Eq {
           eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)})
         }
 
-      case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = $elementTypes }} =>
-        val elemInstances = summonAll(elementTypes)
+      case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = $ElementTypes }} =>
+        val elemInstances = summonAll[ElementTypes]
         val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) => {
           val ordx = '{ $m.ordinal($x) }
           val ordy = '{ $m.ordinal($y) }
diff --git a/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala b/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
index 33984a6ef4dc..a7dd6a183bbb 100644
--- a/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
+++ b/tests/run-macros/quote-matcher-symantics-3/quoted_1.scala
@@ -20,7 +20,7 @@ object Macros {
     object FromEnv {
       def unapply[T](e: Expr[Any])(using env: Env): Option[Expr[R[T]]] =
         e match
-          case '{envVar[$t](${Const(id)})} =>
+          case '{envVar[$_](${Const(id)})} =>
             env.get(id).asInstanceOf[Option[Expr[R[T]]]] // We can only add binds that have the same type as the refs
           case _ =>
             None
@@ -39,11 +39,11 @@ object Macros {
       case '{ ($x: Int) <= ($y: Int) } =>
         '{ $sym.leq(${lift(x)}, ${lift(y)}).asInstanceOf[R[T]] }
 
-      case '{ ${f}($arg: $t): $u } =>
-        '{ $sym.app[$t, $u](${lift(f)}, ${lift(arg)}).asInstanceOf[R[T]] }
+      case '{ ${f}($arg: $A): $B } =>
+        '{ $sym.app[A, B](${lift(f)}, ${lift(arg)}).asInstanceOf[R[T]] }
 
-      case '{ (if ($cond) $thenp else $elsep): $t } =>
-        '{ $sym.ifThenElse[$t](${lift(cond)}, ${lift(thenp)}, ${lift(elsep)}) }.asInstanceOf[Expr[R[T]]]
+      case '{ (if ($cond) $thenp else $elsep): $A } =>
+        '{ $sym.ifThenElse[A](${lift(cond)}, ${lift(thenp)}, ${lift(elsep)}) }.asInstanceOf[Expr[R[T]]]
 
       case '{ (x0: Int) => $bodyFn(x0): Any } =>
         val (i, nEnvVar) = freshEnvVar[Int]()
@@ -60,8 +60,8 @@ object Macros {
         val body2 = UnsafeExpr.open(bodyFn) { (body1, close) => close(body1)(nEnvVar) }
         '{ $sym.lam((x: R[Int => Int]) => ${given Env = envWith(i, 'x)(using env); lift(body2)}).asInstanceOf[R[T]] }
 
-      case '{ Symantics.fix[$t, $u]($f) } =>
-        '{ $sym.fix[$t, $u]((x: R[$t => $u]) => $sym.app(${lift(f)}, x)).asInstanceOf[R[T]] }
+      case '{ Symantics.fix[$A, $B]($f) } =>
+        '{ $sym.fix[A, B]((x: R[A => B]) => $sym.app(${lift(f)}, x)).asInstanceOf[R[T]] }
 
       case FromEnv(expr) => expr.asInstanceOf[Expr[R[T]]]
 
diff --git a/tests/run-macros/quote-matcher-type-bind/Macro_1.scala b/tests/run-macros/quote-matcher-type-bind/Macro_1.scala
index d30b4b16d997..5d52ff8620b5 100644
--- a/tests/run-macros/quote-matcher-type-bind/Macro_1.scala
+++ b/tests/run-macros/quote-matcher-type-bind/Macro_1.scala
@@ -7,8 +7,8 @@ object Macros {
 
   private def impl(x: Expr[Unit])(using QuoteContext): Expr[Unit] = {
     x match {
-      case '{ DSL.f[$t]($x) } => '{ DSL.g[$t]($x) }
-      case '{ DSL.g[$t]($x) } => '{ DSL.f[$t]($x) }
+      case '{ DSL.f[$T]($x) } => '{ DSL.g[T]($x) }
+      case '{ DSL.g[$T]($x) } => '{ DSL.f[T]($x) }
       case _ => x
     }
   }
diff --git a/tests/run-macros/quote-type-matcher-2/quoted_1.scala b/tests/run-macros/quote-type-matcher-2/quoted_1.scala
index d11f5221e25a..a5544333af02 100644
--- a/tests/run-macros/quote-type-matcher-2/quoted_1.scala
+++ b/tests/run-macros/quote-type-matcher-2/quoted_1.scala
@@ -2,17 +2,17 @@ import scala.quoted._
 
 object Macros {
 
-  inline def lift[A]: String = ${ matchesExpr('[A]) }
+  inline def lift[A]: String = ${ matchesExpr[A] }
 
-  private def matchesExpr(tp: Type[_])(using QuoteContext): Expr[String] = {
-    def lift(tp: Type[_]): String = tp match {
+  private def matchesExpr[A](using tp: Type[A])(using QuoteContext): Expr[String] = {
+    def lift[T](using tp: Type[T]): String = tp match {
       case '[Int] => "%Int%"
-      case '[List[$t]] => s"%List[${lift(t)}]%"
-      case '[Option[$t]] => s"%Option[${lift(t)}]%"
-      case '[Function1[$t, $u]] => s"%${lift(t)} => ${lift(u)}%"
+      case '[List[$T]] => s"%List[${lift[T]}]%"
+      case '[Option[$T]] => s"%Option[${lift[T]}]%"
+      case '[Function1[$T, $U]] => s"%${lift[T]} => ${lift[U]}%"
       case _ => tp.show
     }
-    Expr(lift(tp))
+    Expr(lift[A])
   }
 
 }
diff --git a/tests/run-macros/refined-selectable-macro/Macro_1.scala b/tests/run-macros/refined-selectable-macro/Macro_1.scala
index 6023e7f7cfe6..03d2a6279857 100644
--- a/tests/run-macros/refined-selectable-macro/Macro_1.scala
+++ b/tests/run-macros/refined-selectable-macro/Macro_1.scala
@@ -39,7 +39,7 @@ object Macro {
     def tupleElem(name: String, info: Type): Expr[Any] = {
       val nameExpr = Expr(name)
       info.seal match { case '[$qType] =>
-          Expr.ofTupleFromSeq(Seq(nameExpr, '{ $s.selectDynamic($nameExpr).asInstanceOf[$qType] }))
+          Expr.ofTupleFromSeq(Seq(nameExpr, '{ $s.selectDynamic($nameExpr).asInstanceOf[qType] }))
       }
     }
 
@@ -91,8 +91,8 @@ object Macro {
 
     val refinementType = r.foldLeft('[T].unseal.tpe)((acc, e) => Refinement(acc, e._1, e._2)).seal
 
-    refinementType match { case '[$qType] =>
-        '{ $newRecord($s.toArray.map(e => e.asInstanceOf[(String, Any)])).asInstanceOf[${qType}] }
+    refinementType match { case '[$T] =>
+        '{ $newRecord($s.toArray.map(e => e.asInstanceOf[(String, Any)])).asInstanceOf[T] }
     }
   }
 }
diff --git a/tests/run-macros/string-context-implicits/Macro_1.scala b/tests/run-macros/string-context-implicits/Macro_1.scala
index 800b44856397..79a5dac14073 100644
--- a/tests/run-macros/string-context-implicits/Macro_1.scala
+++ b/tests/run-macros/string-context-implicits/Macro_1.scala
@@ -7,8 +7,8 @@ private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using
   argsExpr match {
     case Varargs(argExprs) =>
       val argShowedExprs = argExprs.map {
-        case '{ $arg: $tp } =>
-          val showTp = '[Show[$tp]]
+        case '{ $arg: $Tp } =>
+          val showTp = '[Show[Tp]]
           Expr.summon(using showTp) match {
             case Some(showExpr) => '{ $showExpr.show($arg) }
             case None => report.error(s"could not find implicit for ${showTp.show}", arg); '{???}
diff --git a/tests/run-staging/quote-type-matcher.scala b/tests/run-staging/quote-type-matcher.scala
index bfc13fe9069e..d05bc9dbdf39 100644
--- a/tests/run-staging/quote-type-matcher.scala
+++ b/tests/run-staging/quote-type-matcher.scala
@@ -8,21 +8,21 @@ object Test {
     val '[List[Int]] = '[List[Int]]
 
     '[List[Int]] match
-      case '[List[$int]] =>
-        println(int.show)
+      case '[List[$Int]] =>
+        println(Type[Int].show)
         println()
 
     '[Int => Double] match
-      case  '[Function1[$t1, $r]] =>
-        println(t1.show)
-        println(r.show)
+      case  '[Function1[$T1, $R]] =>
+        println(Type[T1].show)
+        println(Type[R].show)
         println()
 
     '[(Int => Short) => Double] match
-      case '[Function1[Function1[$t1, $r0], $r]] =>
-        println(t1.show)
-        println(r0.show)
-        println(r.show)
+      case '[Function1[Function1[$T1, $R0], $R]] =>
+        println(Type[T1].show)
+        println(Type[R0].show)
+        println(Type[R].show)
 
   }
 }