Simplify quoted.Type implicit search

Now it is a plain `given` definition and follows the normal implicit resulution rules.
Dealiasing of local inconsitent type aliases references are handled by `PCPCheckAndHeal`
before healing is atempted.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

@@ -175,8 +175,10 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       tp match
         case tp: TypeRef =>
           tp.prefix match
-            case NoPrefix if level > levelOf(tp.symbol) =>
-              tryHeal(tp.symbol, tp, pos)
+            case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.InternalQuoted_QuoteTypeTagAnnot) =>
+              val tp1 = tp.dealias
+              if tp1 != tp then apply(tp1)
+              else tryHeal(tp.symbol, tp, pos)
             case prefix: ThisType if !tp.symbol.isStatic && level > levelOf(prefix.cls) =>
               tryHeal(tp.symbol, tp, pos)
             case prefix: TermRef if tp.symbol.isTypeSplice =>

compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -48,20 +48,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       case _ => EmptyTree
   end synthesizedClassTag
 
-  /** Synthesize the tree for `scala.quoted.Type[T]` for an implicit `scala.quoted.Type[T]`.
-   *  `T` is deeply dealiased to avoid references to local type aliases.
-   */
-  val synthesizedTypeTag: SpecialHandler = (formal, span) =>
-    val qctx = ctx.typer.inferImplicitArg(defn.QuoteContextClass.typeRef, span)
-    qctx.tpe match
-      case tpe: Implicits.SearchFailureType => report.error(tpe.msg, ctx.source.atSpan(span))
-      case _ =>
-    val deepDealias = new TypeMap:
-      def apply(tp: Type): Type = mapOver(tp.dealias)
-    val t = deepDealias(formal.select(tpnme.spliceType))
-    ref(defn.QuotedTypeModule_apply).appliedToType(t).select(nme.apply).appliedTo(qctx)
-  end synthesizedTypeTag
-
   val synthesizedTupleFunction: SpecialHandler = (formal, span) =>
     formal match
       case AppliedType(_, funArgs @ fun :: tupled :: Nil) =>
@@ -391,7 +377,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   val specialHandlers = List(
     defn.ClassTagClass        -> synthesizedClassTag,
-    defn.QuotedTypeClass      -> synthesizedTypeTag,
     defn.EqlClass             -> synthesizedEql,
     defn.TupledFunctionClass  -> synthesizedTupleFunction,
     defn.ValueOfClass         -> synthesizedValueOf,

library/src-bootstrapped/scala/quoted/Type.scala

@@ -25,7 +25,7 @@ object Type {
 
   /** Return a quoted.Type with the given type */
   @compileTimeOnly("Reference to `scala.quoted.Type.apply` was not handled by ReifyQuotes")
-  def apply[T <: AnyKind]: QuoteContext ?=> Type[T] = ???
+  given apply[T <: AnyKind] as (QuoteContext ?=> Type[T]) = ???
 
   def UnitTag: QuoteContext ?=> Type[Unit] =
     qctx.tasty.defn.UnitType.seal.asInstanceOf[quoted.Type[Unit]]

tests/run-macros/i7048/Lib_1.scala

@@ -12,7 +12,7 @@ given [U] as IsExpr[Expr[U]] = new IsExpr[Expr[U]] {
 
 def f(x: Any): String = x.toString
 
-def g[T](x: T)(using e: IsExpr[T], tu: Type[e.Underlying]): QuoteContext ?=> Expr[String] = {
+def g[T](x: T)(using e: IsExpr[T])(using tu: Type[e.Underlying]): QuoteContext ?=> Expr[String] = {
   val underlying: Expr[e.Underlying] = e.toExpr(x)
   '{f($underlying)}
 }