Fix quotes with references to path dependent types

Author: nicolasstucki

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

@@ -193,8 +193,10 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       tp match
         case tp: TypeRef =>
           healTypeRef(tp)
-        case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
-          levelError(tp.symbol, tp, pos)
+        case tp: TermRef =>
+          val inconsistentRoot = levelInconsistentRootOfPath(tp)
+          if inconsistentRoot.exists then levelError(inconsistentRoot, tp, pos)
+          else tp
         case tp: AnnotatedType =>
           val newAnnotTree = transform(tp.annot.tree)
           derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
@@ -206,7 +208,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
         case prefix: TermRef if tp.symbol.isTypeSplice =>
           checkNotWildcardSplice(tp)
           if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
-        case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
+        case prefix: TermRef if levelInconsistentRootOfPath(prefix).exists =>
           dealiasAndTryHeal(prefix.symbol, tp, pos)
         case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
           dealiasAndTryHeal(tp.symbol, tp, pos)
@@ -220,6 +222,16 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       if tp1 != tp then apply(tp1)
       else tryHeal(tp.symbol, tp, pos)
 
+    /** Return the root of this path if it is a variable defined in a previous level.
+     *  If the path is consistent, return NoSymbol.
+     */
+    private def levelInconsistentRootOfPath(tp: Type)(using Context): Symbol =
+      tp match
+        case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.termSymbol) => tp.termSymbol
+        case tp @ TermRef(prefix, _) if !tp.symbol.isStatic => levelInconsistentRootOfPath(prefix)
+        case tp: ThisType if level > levelOf(tp.cls) => tp.cls
+        case _ => NoSymbol
+
     private def checkNotWildcardSplice(splice: TypeRef)(using Context): Unit =
       splice.prefix.termSymbol.info.argInfos match
         case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)

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

@@ -222,7 +222,7 @@ class Splicing extends MacroTransform:
                 // Dealias references to captured types
                 TypeTree(tree.tpe.dealias)
             else super.transform(tree)
-        case tree: TypeTree =>
+        case _: TypeTree | _: SingletonTypeTree =>
           if containsCapturedType(tree.tpe) && level >= 1 then getTagRefFor(tree)
           else tree
         case tree @ Assign(lhs: RefTree, rhs) =>
@@ -246,7 +246,7 @@ class Splicing extends MacroTransform:
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
           newContent match
-            case block: Block => 
+            case block: Block =>
               inContext(ctx.withSource(tree.source)) {
                 Apply(TypeApply(typeof, List(newContent)), List(quotes)).withSpan(tree.span)
               }
@@ -342,7 +342,7 @@ class Splicing extends MacroTransform:
       val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (tree, newBinding))._2
       ref(bindingSym)
 
-    private def newQuotedTypeClassBinding(tpe: Type)(using Context) = 
+    private def newQuotedTypeClassBinding(tpe: Type)(using Context) =
       newSymbol(
         spliceOwner,
         UniqueName.fresh(nme.Type).toTermName,
@@ -353,15 +353,15 @@ class Splicing extends MacroTransform:
     private def capturedType(tree: Tree)(using Context): Symbol =
       val tpe = tree.tpe.widenTermRefExpr
       val bindingSym = refBindingMap
-        .getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newQuotedTypeClassBinding(tpe)))._2
+        .getOrElseUpdate(tree.symbol, (TypeTree(tpe), newQuotedTypeClassBinding(tpe)))._2
       bindingSym
 
     private def capturedPartTypes(tpt: Tree)(using Context): Tree =
       val old = healedTypes
       healedTypes = PCPCheckAndHeal.QuoteTypeTags(tpt.span)
       val capturePartTypes = new TypeMap {
         def apply(tp: Type) = tp match {
-          case typeRef @ TypeRef(prefix, _) if isCaptured(prefix.typeSymbol) || isCaptured(prefix.termSymbol) =>
+          case typeRef: TypeRef if containsCapturedType(typeRef) =>
             val termRef = refBindingMap
               .getOrElseUpdate(typeRef.symbol, (TypeTree(typeRef), newQuotedTypeClassBinding(typeRef)))._2.termRef
             val tagRef = healedTypes.nn.getTagRef(termRef)
@@ -376,7 +376,7 @@ class Splicing extends MacroTransform:
       tpt match
         case block: Block =>
           cpy.Block(block)(newHealedTypes ::: block.stats, TypeTree(captured))
-        case _ => 
+        case _ =>
           if newHealedTypes.nonEmpty then
             cpy.Block(tpt)(newHealedTypes, TypeTree(captured))
           else

tests/pos-macros/path-dependent-type-capture.scala

@@ -0,0 +1,67 @@
+import scala.quoted.*
+
+trait A:
+  type T
+  val b: B
+
+trait B:
+  type T
+
+class Test:
+  def testLocalPathsGlobalClasses(using Quotes): Unit =
+    '{
+      type T
+      val a: A = ???
+      ${
+        '{
+          val _: T = ???
+          val _: a.T = ???
+          // val _: a.b.T = ??? // FIXME pickling
+          val _: a.type = ???
+          val _: a.b.type = ???
+        }
+        ???
+      }
+    }
+
+  def testLocalPathsLocalClasses(using Quotes): Unit =
+    '{
+      type U
+      trait C:
+        type U
+        val d: D
+      trait D:
+        type U
+      val c: C = ???
+      ${
+        '{
+          val _: U = ???
+          val _: c.U = ???
+          val _: c.d.U = ???
+          val _: c.type = ???
+          val _: c.d.type = ???
+        }
+        ???
+      }
+    }
+
+  def testThisPaths(using Quotes): Unit =
+    '{
+      trait E:
+        type V
+        val f: F
+        ${
+          '{
+            // val _: this.type = ??? // FIXME pickling E
+            // val _: V = ??? // FIXME pickling E
+            // val _: this.V = ??? // FIXME pickling E
+            val _: this.f.V = ???
+            // val _: this.type = ??? // FIXME pickling E
+            val _: this.f.type = ???
+          }
+          ???
+        }
+      trait F:
+        type V
+      ???
+    }