Make type of type hole available quoted patterns

In general, instances of `scala.quoted.Type` are and should not be used explicitly in quotes.

```diff
+ def f[T](x: T)(using Type[T])(using QuoteContext) =
+   '{ val y: T = $x; ... } // good code

- def f[T](x: T)(using t: Type[T])(using QuoteContext) =
-   '{ val y: t.T = $x; ... } // bad code

- def f[T](x: T)(using t: Type[T])(using QuoteContext) =
-   '{ val y: $t = $x; ... } // bad code (syntax will be removed)
```

The only exception is on types extracted using quoted patterns as these hide tier type inside an instance of `Type[T]` which must be accessed using it's path.
```diff
??? match
  case '{ $x: $t } =>
-   '{ val y: t.T = $x; ... } // bad code
-   '{ val y: $t = $x; ... } // bad code (syntax will be removed)
```

Here `t` is provided as a `given` as if we refer to its type we must be able to summon it.

The change is to provide the name of the type that is extracted rather than the `given Type[T]`.
`Type[T]` can be summoned were needed as in all other uses of abstract types in quotes.

```diff
??? match
  case '{ $x: $T } =>
+   '{ val y: T = $x; ... } // good code
-   val t: Type[T] = summon[Type[T]]
-   '{ val y: t.T = $x; ... } // bad code
-   '{ val y: $t = $x; ... } // bad code (syntax will be removed)
```

The pattern will make `T` and a `given Type[T]` available on the right-hand side of the pattern.
The `T` can be used the same way it could be used in the implementation of a method with signature:
```scala
def f[T](x: T)(using Type[T])(using QuoteContext) =
  '{ val y: T = $x; ... }
```

```scala
case '{ $x: $T } =>
  '{ val y: T = $x; ... }
```

It is also possible to use lower cases for the type splices `case '{ $x: $t } => '{ val y: t = $x; ... }`.
This is similar to the use of type variables in normal patterns `case Some[t](x) =>`.
It is preferable to use upper cases as it makes it clearer that this is a type and renders better on the uses in the right-hand side of the pattern.

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -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 PatMatQuoteTypeEv: UniqueNameKind      = new UniqueNameKind("tpev$")
 
   val LocalOptInlineLocalObj: UniqueNameKind = new UniqueNameKind("ilo")
 

community-build/community-projects/shapeless

@@ -80,15 +80,16 @@ object NameOps {
       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_))
-      }
-    }
+    def isVariableName: Boolean =
+      testSimple { n =>
+        n.length > 0 && {
+          val first = n.head
+          (((first.isLower && first.isLetter) || first == '_')
+            && (n != false_)
+            && (n != true_)
+            && (n != null_))
+        }
+      } || name.is(PatMatQuoteTypeEv)
 
     def isOpAssignmentName: Boolean = name match {
       case raw.NE | raw.LE | raw.GE | EMPTY =>

community-build/community-projects/utest

@@ -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, PatMatQuoteTypeEv}
 import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.core.StdNames._
@@ -156,19 +156,21 @@ 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 = PatMatQuoteTypeEv.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
         case pt: TypeBounds => pt
         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(PatMatQuoteTypeEv.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)
       }

compiler/src/dotty/tools/dotc/core/NameKinds.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 _ =>
   }
 

compiler/src/dotty/tools/dotc/core/NameOps.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
       }

compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.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] ]
   }
 }

tests/neg-macros/quotedPatterns-5.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] ]
   }
 }