Dropping type parameters from typed TypeDefs.

Typed TypeDefs no longer carry tparams. Untyped ones still do, but there is a special PolyTypeDef node for them in untpd.

Also, fixed flatten and DeSugarTest to deal with new tree desugarings which are not idempotent (e.g. desugar.classDef, or desugar.valDef).

2 files changed, 12 insertions, 66 deletions

diff --git a/test/test/DeSugarTest.scala b/test/test/DeSugarTest.scala
index ef0c34ec3..0a3a261fb 100644
--- a/test/test/DeSugarTest.scala
+++ b/test/test/DeSugarTest.scala
@@ -33,11 +33,7 @@ class DeSugarTest extends ParserTest {
 
     override def transform(tree: Tree): Tree = {
       val tree1 = desugar(tree, curMode)
-      if (tree1 ne tree) {
-        //println(s"repeat desugar ${tree1.getClass}")
-        transform(tree1)
-      }
-      else tree1 match {
+      tree1 match {
         case TypedSplice(t) =>
           tree1
         case PostfixOp(od, op) =>
@@ -62,12 +58,14 @@ class DeSugarTest extends ParserTest {
           tree1.derivedValDef(mods, name, transform(tpt, Type), transform(rhs))
         case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
           tree1.derivedDefDef(mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt, Type), transform(rhs))
-        case TypeDef(mods, name, tparams, rhs) =>
-          tree1.derivedTypeDef(mods, name, transformSub(tparams), transform(rhs, Type))
+        case tree1 @ TypeDef(mods, name, rhs) =>
+          tree1.derivedTypeDef(mods, name, transform(rhs, Type), transformSub(tree1.tparams))
         case Template(constr, parents, self, body) =>
           tree1.derivedTemplate(transformSub(constr), transform(parents), transformSub(self), transform(body, Expr))
         case ClassDef(mods, name, impl) =>
           tree1.derivedClassDef(mods, name, transformSub(impl))
+        case Thicket(trees) =>
+          Thicket(flatten(trees mapConserve super.transform))
         case tree1 =>
           super.transform(tree1)
       }
diff --git a/test/test/showTree.scala b/test/test/showTree.scala
index 5d2710715..957131cf7 100644
--- a/test/test/showTree.scala
+++ b/test/test/showTree.scala
@@ -4,72 +4,20 @@ import ast.Trees._
 import ast.desugar
 import ast.desugar._
 
-object showTree extends ParserTest {
+object showTree extends DeSugarTest {
 
   import dotty.tools.dotc.ast.untpd._
 
   import Mode._
 
-  object DeSugar extends TreeTransformer {
-    var curMode: Mode.Value = Mode.Expr
-    def withMode[T](mode: Mode.Value)(op: => T) = {
-      val saved = curMode
-      curMode = mode
-      try op
-      finally curMode = saved
-    }
-
-    def transform(tree: Tree, mode: Mode.Value): Tree = withMode(mode) { transform(tree) }
-    def transform(trees: List[Tree], mode: Mode.Value): List[Tree] = withMode(mode) { transform(trees) }
-
-    override def transform(tree: Tree): Tree = {
-      val tree1 = desugar(tree, curMode)
-      if (tree1 ne tree) {
-        //println(s"repeat desugar ${tree1.getClass}")
-        transform(tree1)
-      }
-      else tree1 match {
-        case TypedSplice(t) =>
-          tree1
-        case PostfixOp(od, op) =>
-          PostfixOp(transform(od), op)
-        case Select(qual, name) =>
-          tree1.derivedSelect(transform(qual, Expr), name)
-        case Apply(fn, args) =>
-          tree1.derivedApply(transform(fn, Expr), transform(args))
-        case TypeApply(fn, args) =>
-          tree1.derivedTypeApply(transform(fn, Expr), transform(args, Type))
-        case New(tpt) =>
-          tree1.derivedNew(transform(tpt, Type))
-        case Typed(expr, tpt) =>
-          tree1.derivedTyped(transform(expr), transform(tpt, Type))
-        case CaseDef(pat, guard, body) =>
-          tree1.derivedCaseDef(transform(pat, Pattern), transform(guard), transform(body))
-        case SeqLiteral(elempt, elems) =>
-          tree1.derivedSeqLiteral(transform(elempt, Type), transform(elems))
-        case UnApply(fun, args) =>
-          tree1.derivedUnApply(transform(fun, Expr), transform(args))
-        case ValDef(mods, name, tpt, rhs) =>
-          tree1.derivedValDef(mods, name, transform(tpt, Type), transform(rhs))
-        case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-          tree1.derivedDefDef(mods, name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt, Type), transform(rhs))
-        case TypeDef(mods, name, tparams, rhs) =>
-          tree1.derivedTypeDef(mods, name, transformSub(tparams), transform(rhs, Type))
-        case Template(constr, parents, self, body) =>
-          tree1.derivedTemplate(transformSub(constr), transform(parents), transformSub(self), transform(body, Expr))
-        case ClassDef(mods, name, impl) =>
-          tree1.derivedClassDef(mods, name, transformSub(impl))
-        case tree1 =>
-          super.transform(tree1)
-      }
-    }
+  def test(arg: String) = {
+    val tree: Tree = parse(arg)
+    println("result = "+tree.show)
+    println("desugared = "+DeSugar.transform(tree).show)
   }
 
   def main(args: Array[String]): Unit = {
-    for (arg <- args) {
-      val tree: Tree = parse(arg)
-      println("result = "+tree.show)
-      println("desugared = "+DeSugar.transform(tree).show)
-    }
+    test("src/dotty/tools/dotc/core/Types.scala")
+    for (arg <- args) test(arg)
   }
 }
\ No newline at end of file