Create RetypingTreeMap that propagates types

If some node in tree is transformed changing the type,
the outer node could potentially also change type.

This patch implements a RetypingTreeMap that propagates those
changes until types converge. Propagation is done for tree nodes
that are able to compute their type based on their children:
Pair, Block, If, Match, CaseDef, Try, SeqLiteral, Annotated, Select.

1 files changed, 19 insertions, 18 deletions

diff --git a/src/dotty/tools/dotc/ast/Trees.scala b/src/dotty/tools/dotc/ast/Trees.scala
index 8a36fee3a..e19221841 100644
--- a/src/dotty/tools/dotc/ast/Trees.scala
+++ b/src/dotty/tools/dotc/ast/Trees.scala
@@ -1109,36 +1109,20 @@ object Trees {
           cpy.Apply(tree, transform(fun), transform(args))
         case TypeApply(fun, args) =>
           cpy.TypeApply(tree, transform(fun), transform(args))
-        case Literal(const) =>
-          tree
         case New(tpt) =>
           cpy.New(tree, transform(tpt))
-        case Pair(left, right) =>
-          cpy.Pair(tree, transform(left), transform(right))
         case Typed(expr, tpt) =>
           cpy.Typed(tree, transform(expr), transform(tpt))
         case NamedArg(name, arg) =>
           cpy.NamedArg(tree, name, transform(arg))
         case Assign(lhs, rhs) =>
           cpy.Assign(tree, transform(lhs), transform(rhs))
-        case Block(stats, expr) =>
-          cpy.Block(tree, transformStats(stats), transform(expr))
-        case If(cond, thenp, elsep) =>
-          cpy.If(tree, transform(cond), transform(thenp), transform(elsep))
         case Closure(env, meth, tpt) =>
           cpy.Closure(tree, transform(env), transform(meth), transform(tpt))
-        case Match(selector, cases) =>
-          cpy.Match(tree, transform(selector), transformSub(cases))
-        case CaseDef(pat, guard, body) =>
-          cpy.CaseDef(tree, transform(pat), transform(guard), transform(body))
         case Return(expr, from) =>
           cpy.Return(tree, transform(expr), transformSub(from))
-        case Try(block, handler, finalizer) =>
-          cpy.Try(tree, transform(block), transform(handler), transform(finalizer))
         case Throw(expr) =>
           cpy.Throw(tree, transform(expr))
-        case SeqLiteral(elems) =>
-          cpy.SeqLiteral(tree, transform(elems))
         case TypeTree(original) =>
           tree
         case SingletonTypeTree(ref) =>
@@ -1177,12 +1161,29 @@ object Trees {
           cpy.Import(tree, transform(expr), selectors)
         case PackageDef(pid, stats) =>
           cpy.PackageDef(tree, transformSub(pid), transformStats(stats))
-        case Annotated(annot, arg) =>
-          cpy.Annotated(tree, transform(annot), transform(arg))
         case Thicket(trees) =>
           val trees1 = transform(trees)
           if (trees1 eq trees) tree else Thicket(trees1)
+        case Literal(const) =>
+          tree
+        case Pair(left, right) =>
+          cpy.Pair(tree, transform(left), transform(right))
+        case Block(stats, expr) =>
+          cpy.Block(tree, transformStats(stats), transform(expr))
+        case If(cond, thenp, elsep) =>
+          cpy.If(tree, transform(cond), transform(thenp), transform(elsep))
+        case Match(selector, cases) =>
+          cpy.Match(tree, transform(selector), transformSub(cases))
+        case CaseDef(pat, guard, body) =>
+          cpy.CaseDef(tree, transform(pat), transform(guard), transform(body))
+        case Try(block, handler, finalizer) =>
+          cpy.Try(tree, transform(block), transform(handler), transform(finalizer))
+        case SeqLiteral(elems) =>
+          cpy.SeqLiteral(tree, transform(elems))
+        case Annotated(annot, arg) =>
+          cpy.Annotated(tree, transform(annot), transform(arg))
       }
+
       def transformStats(trees: List[Tree])(implicit ctx: Context): List[Tree] =
         transform(trees)
       def transform(trees: List[Tree])(implicit ctx: Context): List[Tree] =