Introduce UntypedSplice

Introduce UntypedSplice and make TreeCopiers and TreeMaps more regular
to take splices into account.

Author: odersky

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

@@ -11,7 +11,7 @@ import core.tasty.TreePickler.Hole
 
 /** A map that applies three functions and a substitution together to a tree and
  *  makes sure they are coordinated so that the result is well-typed. The functions are
- *  @param  typeMap  A function from Type to Type that gets applied to the
+ *  @param typeMap   A function from Type to Type that gets applied to the
  *                   type of every tree node and to all locally defined symbols,
  *                   followed by the substitution [substFrom := substTo].
  *  @param treeMap   A transformer that translates all encountered subtrees in
@@ -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.TreeMap {
+  val substTo: List[Symbol] = Nil)(implicit ctx: Context) extends tpd.TypedTreeMap {
   import tpd._
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */

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

@@ -1148,6 +1148,9 @@ object Trees {
 
     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)
+
       def transform(tree: Tree)(implicit ctx: Context): Tree = {
         Stats.record(s"TreeMap.transform $getClass")
         Stats.record("TreeMap.transform total")
@@ -1245,8 +1248,8 @@ object Trees {
           case Thicket(trees) =>
             val trees1 = transform(trees)
             if (trees1 eq trees) tree else Thicket(trees1)
-          case _ if ctx.reporter.errorsReported =>
-            tree
+          case _ =>
+            handleMoreCases(tree)
         }
       }
 

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

@@ -324,7 +324,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case pre: ThisType =>
         tp.isType ||
         pre.cls.isStaticOwner ||
-          tp.symbol.isParamOrAccessor && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
+        tp.symbol.isParamOrAccessor && !pre.cls.is(Trait) && ctx.owner.enclosingClass == pre.cls
           // was ctx.owner.enclosingClass.derivesFrom(pre.cls) which was not tight enough
           // and was spuriously triggered in case inner class would inherit from outer one
           // eg anonymous TypeMap inside TypeMap.andThen
@@ -471,6 +471,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       } else foldOver(sym, tree)
   }
 
+  case class UntypedSplice(splice: untpd.Tree) extends Tree
+
   override val cpy: TypedTreeCopier = // Type ascription needed to pick up any new members in TreeCopier (currently there are none)
     new TypedTreeCopier
 
@@ -609,6 +611,11 @@ 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 =
@@ -638,6 +645,18 @@ 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

@@ -24,8 +24,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** A typed subtree of an untyped tree needs to be wrapped in a TypedSlice
    *  @param owner  The current owner at the time the tree was defined
    */
-  abstract case class TypedSplice(tree: tpd.Tree)(val owner: Symbol) extends ProxyTree {
-    def forwardTo = tree
+  abstract case class TypedSplice(splice: tpd.Tree)(val owner: Symbol) extends ProxyTree {
+    def forwardTo = splice
   }
 
   object TypedSplice {
@@ -496,10 +496,16 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs))
     }
+    def TypedSplice(tree: Tree)(splice: tpd.Tree)(implicit ctx: Context) = tree match {
+      case tree: TypedSplice if splice `eq` tree.splice => tree
+      case _ => finalize(tree, untpd.TypedSplice(splice))
+    }
   }
 
   abstract class UntypedTreeMap(cpy: UntypedTreeCopier = untpd.cpy) extends TreeMap(cpy) {
-    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+    protected def typedMap: tpd.Tree => tpd.Tree = identity
+
+    override def handleMoreCases(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case ModuleDef(name, impl) =>
         cpy.ModuleDef(tree)(name, transformSub(impl))
       case ParsedTry(expr, handler, finalizer) =>
@@ -540,10 +546,10 @@ 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(_) =>
-        tree
+      case TypedSplice(splice) =>
+        cpy.TypedSplice(tree)(typedMap(splice))
       case _ =>
-        super.transform(tree)
+        super.handleMoreCases(tree)
     }
   }
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -446,6 +446,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case TypedSplice(t) =>
         if (ctx.settings.YprintDebug.value) "[" ~ toText(t) ~ "]#TS#"
         else toText(t)
+      case tpd.UntypedSplice(t) =>
+        if (ctx.settings.YprintDebug.value) "[" ~ toText(t) ~ "]#US#"      
+        toText(t)
       case tree @ ModuleDef(name, impl) =>
         withEnclosingDef(tree) {
           modText(tree.mods, NoSymbol, keywordStr("object")) ~~ nameIdText(tree) ~ toTextTemplate(impl)

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

@@ -59,6 +59,8 @@ abstract class MacroTransform extends Phase {
               transform(parents)(ctx.superCallContext),
               transformSelf(self),
               transformStats(impl.body, tree.symbol))
+          case UntypedSplice(_) =>
+            tree
           case _ =>
             super.transform(tree)
         }

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

@@ -1665,7 +1665,7 @@ class Typer extends Namer
   }
 
   def typedTypedSplice(tree: untpd.TypedSplice)(implicit ctx: Context): Tree =
-    tree.tree match {
+    tree.splice match {
       case tree1: TypeTree => tree1  // no change owner necessary here ...
       case tree1: Ident => tree1     // ... or here, since these trees cannot contain bindings
       case tree1 =>