Dealias quoted types when staging

This change improves the code generation of the contents of splices. In
the splicing phase, we have to find all types that are defined in the
quote but used in the splice. When there are type aliases, we can end up
with several `Type[T]` for the different aliases of `T`. By dealiasing
during the staging phase (just before splicing phase) we make sure that
the splicer phase will only generate one `Type[T]`.

By dealiasing we also optimize some situations where a type from outside
a quote is inserted in the quoted code and then used in one of its
splice through an alias. In this situation we can use the outer
`Type[T]` directly.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1374,54 +1374,57 @@ object Types {
             case Atoms.Unknown => Atoms.Unknown
         case _ => Atoms.Unknown
 
-    private def dealias1(keep: AnnotatedType => Context ?=> Boolean, keepOpaques: Boolean)(using Context): Type = this match {
+    private def dealias1(keep: AnnotatedType => Context ?=> Boolean, keepOpaques: Boolean, keepSplicedTypes: Boolean)(using Context): Type = this match {
       case tp: TypeRef =>
         if (tp.symbol.isClass) tp
         else tp.info match {
-          case TypeAlias(alias) if !(keepOpaques && tp.symbol.is(Opaque)) =>
-            alias.dealias1(keep, keepOpaques)
+          case TypeAlias(alias) if !(keepOpaques && tp.symbol.is(Opaque)) && !(keepSplicedTypes && tp.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot)) =>
+            alias.dealias1(keep, keepOpaques, keepSplicedTypes)
           case _ => tp
         }
       case app @ AppliedType(tycon, _) =>
-        val tycon1 = tycon.dealias1(keep, keepOpaques)
-        if (tycon1 ne tycon) app.superType.dealias1(keep, keepOpaques)
+        val tycon1 = tycon.dealias1(keep, keepOpaques, keepSplicedTypes)
+        if (tycon1 ne tycon) app.superType.dealias1(keep, keepOpaques, keepSplicedTypes)
         else this
       case tp: TypeVar =>
         val tp1 = tp.instanceOpt
-        if (tp1.exists) tp1.dealias1(keep, keepOpaques) else tp
+        if (tp1.exists) tp1.dealias1(keep, keepOpaques, keepSplicedTypes) else tp
       case tp: AnnotatedType =>
-        val parent1 = tp.parent.dealias1(keep, keepOpaques)
+        val parent1 = tp.parent.dealias1(keep, keepOpaques, keepSplicedTypes)
         tp match
           case tp @ CapturingType(parent, refs) =>
             tp.derivedCapturingType(parent1, refs)
           case _ =>
             if keep(tp) then tp.derivedAnnotatedType(parent1, tp.annot)
             else parent1
       case tp: LazyRef =>
-        tp.ref.dealias1(keep, keepOpaques)
+        tp.ref.dealias1(keep, keepOpaques, keepSplicedTypes)
       case _ => this
     }
 
     /** Follow aliases and dereferences LazyRefs, annotated types and instantiated
      *  TypeVars until type is no longer alias type, annotated type, LazyRef,
      *  or instantiated type variable.
      */
-    final def dealias(using Context): Type = dealias1(keepNever, keepOpaques = false)
+    final def dealias(using Context): Type = dealias1(keepNever, keepOpaques = false, keepSplicedTypes = false)
 
     /** Follow aliases and dereferences LazyRefs and instantiated TypeVars until type
      *  is no longer alias type, LazyRef, or instantiated type variable.
      *  Goes through annotated types and rewraps annotations on the result.
      */
-    final def dealiasKeepAnnots(using Context): Type = dealias1(keepAlways, keepOpaques = false)
+    final def dealiasKeepAnnots(using Context): Type = dealias1(keepAlways, keepOpaques = false, keepSplicedTypes = false)
 
     /** Like `dealiasKeepAnnots`, but keeps only refining annotations */
-    final def dealiasKeepRefiningAnnots(using Context): Type = dealias1(keepIfRefining, keepOpaques = false)
+    final def dealiasKeepRefiningAnnots(using Context): Type = dealias1(keepIfRefining, keepOpaques = false, keepSplicedTypes = false)
 
     /** Follow non-opaque aliases and dereferences LazyRefs, annotated types and instantiated
      *  TypeVars until type is no longer alias type, annotated type, LazyRef,
      *  or instantiated type variable.
      */
-    final def dealiasKeepOpaques(using Context): Type = dealias1(keepNever, keepOpaques = true)
+    final def dealiasKeepOpaques(using Context): Type = dealias1(keepNever, keepOpaques = true, keepSplicedTypes = false)
+
+    /** Like `dealias`, but keeps aliases marked with `@SplicedType` */
+    final def dealiasKeepSpliceTypes(using Context): Type = dealias1(keepNever, keepOpaques = true, keepSplicedTypes = true)
 
     /** Approximate this type with a type that does not contain skolem types. */
     final def deskolemized(using Context): Type =
@@ -1449,7 +1452,7 @@ object Types {
     def tryNormalize(using Context): Type = NoType
 
     private def widenDealias1(keep: AnnotatedType => Context ?=> Boolean)(using Context): Type = {
-      val res = this.widen.dealias1(keep, keepOpaques = false)
+      val res = this.widen.dealias1(keep, keepOpaques = false, keepSplicedTypes = false)
       if (res eq this) res else res.widenDealias1(keep)
     }
 

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

@@ -118,12 +118,29 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       val targs2 = targs.map(targ => TypeTree(healTypeOfTerm(quote.fun.srcPos)(targ.tpe)))
       cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), body2 :: Nil)
     else
-      val quotes = quote.args.mapConserve(transform)
-      body.tpe match
-        case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
-          // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
-          ref(x)
+      object DirectTypeOfRef:
+        def unapply(body: Tree): Option[Tree] =
+          body.tpe match
+            case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
+              // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+              Some(ref(x).withSpan(quote.span))
+            case _ =>
+              body2 match
+                case Block(List(tdef: TypeDef), tpt: TypeTree) =>
+                  tpt.tpe match
+                    case tpe: TypeRef if tpe.typeSymbol == tdef.symbol =>
+                      tdef.rhs.tpe.hiBound match
+                        case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
+                          // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
+                          Some(ref(x).withSpan(quote.span))
+                        case _ => None
+                    case _ => None
+                case _ => None
+
+      body match
+        case DirectTypeOfRef(ref) => ref
         case _ =>
+          val quotes = quote.args.mapConserve(transform)
           // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
           val TypeApply(fun, _) = quote.fun: @unchecked
           cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, body2 :: Nil), quotes)
@@ -190,7 +207,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     def apply(tp: Type): Type =
       tp match
         case tp: TypeRef =>
-          tp.prefix match
+          val tp1 = tp.dealiasKeepSpliceTypes
+          if tp1 != tp && levelOf(tp.symbol) > 0 then apply(tp1)
+          else tp.prefix match
             case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
               tryHealTypeOfType(tp.symbol, tp, pos)
             case prefix: ThisType if !tp.symbol.isStatic && level > levelOf(prefix.cls) =>
@@ -222,7 +241,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
      *  Emits and error if `T` cannot be healed and returns `T`.
      */
     private def tryHealTypeOfType(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): Type = {
-      val tp1 = tp.dealias
+      val tp1 = tp.dealiasKeepSpliceTypes
       if tp1 != tp then apply(tp1)
       else tryHeal(tp.symbol, tp, pos)
     }

tests/pos-macros/i8100b.scala

@@ -0,0 +1,35 @@
+import scala.quoted.*
+
+def f[T: Type](using Quotes) =
+  '{
+    type T2 = T
+    ${
+
+      val t0: T = ???
+      val t1: T2 = ???
+      val tp = Type.of[T]
+      val tp1 = Type.of[T2]
+      '{
+        val t3: T = ???
+        val t4: T2 = ???
+      }
+    }
+  }
+
+def g(using Quotes) =
+  '{
+    type U
+    type U2 = U
+    ${
+
+      val u1: U = ???
+      val u2: U2 = ???
+
+      val tp = Type.of[U]
+      val tp1 = Type.of[U2]
+      '{
+        val u3: U = ???
+        val u4: U2 = ???
+      }
+    }
+  }

tests/run-staging/quote-nested-3.check

@@ -1,7 +1,7 @@
 {
   type T = scala.Predef.String
   val x: java.lang.String = "foo"
-  val z: T = x
+  val z: java.lang.String = x
 
   (x: java.lang.String)
 }

tests/run-staging/quote-nested-6.check

@@ -1,7 +1,7 @@
 {
   type T[X] = scala.List[X]
   val x: java.lang.String = "foo"
-  val z: T[scala.Predef.String] = scala.List.apply[java.lang.String](x)
+  val z: [X >: scala.Nothing <: scala.Any] => scala.collection.immutable.List[X][scala.Predef.String] = scala.List.apply[java.lang.String](x)
 
   (x: java.lang.String)
 }

tests/run-staging/quote-owners-2.check

@@ -2,7 +2,7 @@
   def ff: scala.Int = {
     val a: scala.collection.immutable.List[scala.Int] = {
       type T = scala.collection.immutable.List[scala.Int]
-      val b: T = scala.Nil.::[scala.Int](3)
+      val b: scala.collection.immutable.List[scala.Int] = scala.Nil.::[scala.Int](3)
 
       (b: scala.collection.immutable.List[scala.Int])
     }