Use tpd.patVars

Author: nicolasstucki

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

@@ -70,11 +70,10 @@ object Splicer {
   def checkEscapedVariables(tree: Tree, expansionOwner: Symbol)(given ctx: Context): tree.type =
     new TreeTraverser {
       private[this] var locals = Set.empty[Symbol]
+      private def markSymbol(sym: Symbol)(implicit ctx: Context): Unit =
+          locals = locals + sym
       private def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
-        case tree: DefTree =>
-          val sym = tree.symbol
-          if (!locals.contains(sym))
-            locals = locals + sym
+        case tree: DefTree => markSymbol(tree.symbol)
         case _ =>
       }
       def traverse(tree: Tree)(given ctx: Context): Unit =
@@ -91,13 +90,7 @@ object Splicer {
             traverseOver(last)
           case CaseDef(pat, guard, body) =>
             val last = locals
-            // mark all bindings
-            new TreeTraverser {
-              def traverse(tree: Tree)(implicit ctx: Context): Unit = {
-                markDef(tree)
-                traverseChildren(tree)
-              }
-            }.traverse(pat)
+            tpd.patVars(pat).foreach(markSymbol)
             traverseOver(last)
           case _ =>
             markDef(tree)

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

@@ -47,14 +47,16 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
   /** Localy defined symbols seen so far by `StagingTransformer.transform` */
   protected def localSymbols: List[Symbol] = enteredSyms
 
+  /** Enter staging level of symbol defined by `tree`, if applicable. */
+  private def markSymbol(sym: Symbol)(implicit ctx: Context): Unit =
+    if ((sym.isClass || sym.maybeOwner.isTerm) && !levelOfMap.contains(sym)) {
+      levelOfMap(sym) = level
+      enteredSyms = sym :: enteredSyms
+  }
+
   /** Enter staging level of symbol defined by `tree`, if applicable. */
   private def markDef(tree: Tree)(implicit ctx: Context): Unit = tree match {
-    case tree: DefTree =>
-      val sym = tree.symbol
-      if ((sym.isClass || sym.maybeOwner.isTerm) && !levelOfMap.contains(sym)) {
-        levelOfMap(sym) = level
-        enteredSyms = sym :: enteredSyms
-      }
+    case tree: DefTree => markSymbol(tree.symbol)
     case _ =>
   }
 
@@ -106,16 +108,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
 
         case CaseDef(pat, guard, body) =>
           val last = enteredSyms
-          // mark all bindings
-          new TreeTraverser {
-            def traverse(tree: Tree)(implicit ctx: Context): Unit = tree match {
-              case Quoted(t) => traverse(t)(quoteContext)
-              case Splice(t) => traverse(t)(spliceContext)
-              case _ =>
-                markDef(tree)
-                traverseChildren(tree)
-            }
-          }.traverse(pat)
+          tpd.patVars(pat).foreach(markSymbol)
           mapOverTree(last)
 
         case _: Import =>