More robust scheme for untyped splices

 - extend scheme to accumulators
 - no need anymore to define special tpd versions of maps and accumulators
 - no extra `typeMap` field needed in typeMap; instead the UntypedSplice
   case is handled directly.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -38,7 +38,7 @@ class TreeTypeMap(
   val oldOwners: List[Symbol] = Nil,
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
-  val substTo: List[Symbol] = Nil)(implicit ctx: Context) extends tpd.TypedTreeMap {
+  val substTo: List[Symbol] = Nil)(implicit ctx: Context) extends tpd.TreeMap {
   import tpd._
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -1109,6 +1109,10 @@ object Trees {
         case tree: Annotated if (arg eq tree.arg) && (annot eq tree.annot) => tree
         case _ => finalize(tree, untpd.Annotated(arg, annot))
       }
+      def UntypedSplice(tree: Tree)(splice: untpd.Tree) = tree match {
+        case tree: tpd.UntypedSplice if tree.splice `eq` splice => tree
+        case _ => finalize(tree, tpd.UntypedSplice(splice))
+      }
       def Thicket(tree: Tree)(trees: List[Tree]): Thicket = tree match {
         case tree: Thicket if trees eq tree.trees => tree
         case _ => finalize(tree, untpd.Thicket(trees))
@@ -1146,10 +1150,7 @@ object Trees {
      */
     protected def inlineContext(call: Tree)(implicit ctx: Context): Context = ctx
 
-    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) {
-
-      protected def handleMoreCases(tree: Tree)(implicit ctx: Context): Tree =
-        if (ctx.reporter.errorsReported) tree else throw new MatchError(tree)
+    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
 
       def transform(tree: Tree)(implicit ctx: Context): Tree = {
         Stats.record(s"TreeMap.transform $getClass")
@@ -1249,7 +1250,7 @@ object Trees {
             val trees1 = transform(trees)
             if (trees1 eq trees) tree else Thicket(trees1)
           case _ =>
-            handleMoreCases(tree)
+            transformMoreCases(tree)
         }
       }
 
@@ -1261,9 +1262,26 @@ object Trees {
         transform(tree).asInstanceOf[Tr]
       def transformSub[Tr <: Tree](trees: List[Tr])(implicit ctx: Context): List[Tr] =
         transform(trees).asInstanceOf[List[Tr]]
+
+      protected def transformMoreCases(tree: Tree)(implicit ctx: Context): Tree = tree match {
+        case tpd.UntypedSplice(usplice) =>
+          // For a typed tree map: homomorphism on the untyped part with
+          // recursive mapping of typed splices.
+          // The case is overridden in UntypedTreeMap.##
+          val untpdMap = new untpd.UntypedTreeMap {
+            override def transform(tree: untpd.Tree)(implicit ctx: Context): untpd.Tree = tree match {
+              case untpd.TypedSplice(tsplice) =>
+                untpd.cpy.TypedSplice(tree)(self.transform(tsplice).asInstanceOf[tpd.Tree])
+                  // the cast is safe, since the UntypedSplice case is overridden in UntypedTreeMap.
+              case _ => super.transform(tree)
+            }
+          }
+          cpy.UntypedSplice(tree)(untpdMap.transform(usplice))
+        case _ if ctx.reporter.errorsReported => tree
+      }
     }
 
-    abstract class TreeAccumulator[X] {
+    abstract class TreeAccumulator[X] { self =>
       // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
       def apply(x: X, tree: Tree)(implicit ctx: Context): X
 
@@ -1358,14 +1376,29 @@ object Trees {
             this(this(x, arg), annot)
           case Thicket(ts) =>
             this(x, ts)
-          case _ if ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive) =>
-            // In interactive mode, errors might come from previous runs.
-            // In case of errors it may be that typed trees point to untyped ones.
-            // The IDE can still traverse inside such trees, either in the run where errors
-            // are reported, or in subsequent ones.
-            x
+          case _ =>
+            foldMoreCases(x, tree)
         }
       }
+
+      def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = tree match {
+        case tpd.UntypedSplice(usplice) =>
+          // For a typed tree accumulator: skip the untyped part and fold all typed splices.
+          // The case is overridden in UntypedTreeAccumulator.
+          val untpdAcc = new untpd.UntypedTreeAccumulator[X] {
+            override def apply(x: X, tree: untpd.Tree)(implicit ctx: Context): X = tree match {
+              case untpd.TypedSplice(tsplice) => self(x, tsplice)
+              case _ => foldOver(x, tree)
+            }
+          }
+          untpdAcc(x, usplice)
+        case _ if ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive) =>
+          // In interactive mode, errors might come from previous runs.
+          // In case of errors it may be that typed trees point to untyped ones.
+          // The IDE can still traverse inside such trees, either in the run where errors
+          // are reported, or in subsequent ones.
+          x
+      }
     }
 
     abstract class TreeTraverser extends TreeAccumulator[Unit] {

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -611,11 +611,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    def UntypedSplice(tree: Tree)(splice: untpd.Tree) = tree match {
-      case tree: tpd.UntypedSplice if tree.splice `eq` splice => tree
-      case _ => finalize(tree, tpd.UntypedSplice(splice))
-    }
-
     override def If(tree: If)(cond: Tree = tree.cond, thenp: Tree = tree.thenp, elsep: Tree = tree.elsep)(implicit ctx: Context): If =
       If(tree: Tree)(cond, thenp, elsep)
     override def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(implicit ctx: Context): Closure =
@@ -645,18 +640,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(tree: Tree)(env, meth, tpt)
   }
 
-  class TypedTreeMap(cpy: TypedTreeCopier = tpd.cpy) extends TreeMap(cpy) { self =>
-    override def handleMoreCases(tree: Tree)(implicit ctx: Context) = tree match {
-      case UntypedSplice(utree) =>
-        val umap = new untpd.UntypedTreeMap() {
-          override def typedMap = self.transform(_)
-        }
-        cpy.UntypedSplice(tree)(umap.transform(utree))
-      case _ =>
-        super.handleMoreCases(tree)
-    }
-  }
-
   override def skipTransform(tree: Tree)(implicit ctx: Context) = tree.tpe.isError
 
   implicit class TreeOps[ThisTree <: tpd.Tree](val tree: ThisTree) extends AnyVal {

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -503,9 +503,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
 
   abstract class UntypedTreeMap(cpy: UntypedTreeCopier = untpd.cpy) extends TreeMap(cpy) {
-    protected def typedMap: tpd.Tree => tpd.Tree = identity
-
-    override def handleMoreCases(tree: Tree)(implicit ctx: Context): Tree = tree match {
+    override def transformMoreCases(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case ModuleDef(name, impl) =>
         cpy.ModuleDef(tree)(name, transformSub(impl))
       case ParsedTry(expr, handler, finalizer) =>
@@ -546,15 +544,17 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
-      case TypedSplice(splice) =>
-        cpy.TypedSplice(tree)(typedMap(splice))
+      case tpd.UntypedSplice(splice) =>
+        cpy.UntypedSplice(tree)(transform(splice))
+      case TypedSplice(_) =>
+        tree
       case _ =>
-        super.handleMoreCases(tree)
+        super.transformMoreCases(tree)
     }
   }
 
-  abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] {
-    override def foldOver(x: X, tree: Tree)(implicit ctx: Context): X = tree match {
+  abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] { self =>
+    override def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = tree match {
       case ModuleDef(name, impl) =>
         this(x, impl)
       case ParsedTry(expr, handler, finalizer) =>
@@ -595,10 +595,12 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(x, bounds), cxBounds)
       case PatDef(mods, pats, tpt, rhs) =>
         this(this(this(x, pats), tpt), rhs)
-      case TypedSplice(tree) =>
-        this(x, tree)
+      case TypedSplice(splice) =>
+        this(x, splice)
+      case tpd.UntypedSplice(splice) =>
+        this(x, splice)
       case _ =>
-        super.foldOver(x, tree)
+        super.foldMoreCases(x, tree)
     }
   }