Added tests for desugaring.

6 files changed, 244 insertions, 24 deletions

diff --git a/test/test/DeSugarTest.scala b/test/test/DeSugarTest.scala
new file mode 100644
index 000000000..71274674b
--- /dev/null
+++ b/test/test/DeSugarTest.scala
@@ -0,0 +1,95 @@
+package test
+
+import scala.reflect.io._
+import dotty.tools.dotc.util._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.parsing._
+import Tokens._, Parsers._
+import org.junit.Test
+import dotty.tools.dotc._
+import ast.Trees._
+
+import scala.collection.mutable.ListBuffer
+
+class DeSugarTest extends ParserTest {
+
+  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, tparams, impl) =>
+          tree1.derivedClassDef(mods, name, transformSub(tparams), transformSub(impl))
+        case tree1 =>
+          super.transform(tree1)
+      }
+    }
+  }
+
+  def firstClass(stats: List[Tree]): String = stats match {
+    case Nil => "<empty>"
+    case ClassDef(_, name, _, _) :: _ => name.toString
+    case ModuleDef(_, name, _) :: _ => name.toString
+    case (pdef: PackageDef) :: _ => firstClass(pdef)
+    case stat :: stats => firstClass(stats)
+  }
+
+  def firstClass(tree: Tree): String = tree match {
+    case PackageDef(pid, stats) =>
+      pid.show + "." + firstClass(stats)
+    case _ => "??? "+tree.getClass
+  }
+
+  def desugarTree(tree: Tree): Tree = {
+    //println("***** desugaring "+firstClass(tree))
+    DeSugar.transform(tree)
+  }
+
+  def desugarAll() = parsedTrees foreach (desugarTree(_).show)
+}
\ No newline at end of file
diff --git a/test/test/ParserTest.scala b/test/test/ParserTest.scala
index 49a1ff7b6..291b27983 100644
--- a/test/test/ParserTest.scala
+++ b/test/test/ParserTest.scala
@@ -39,22 +39,4 @@ class ParserTest extends DottyTest {
     for (d <- dir.dirs)
       parseDir(d.path)
   }
-/*
-  @Test
-  def parseList() = {
-    println(System.getProperty("user.dir"))
-    parse("src/dotty/tools/dotc/core/Symbols.scala")
-    parse("src/dotty/tools/dotc/core/Types.scala")
-  }
-
-  @Test
-  def parseDotty() = {
-    parseDir("src")
-  }*/
-
-  @Test
-  def parseScala() = {
-    parseDir("/Users/odersky/workspace/scala/src")
-  }
-
 }
\ No newline at end of file
diff --git a/test/test/desugarPackage.scala b/test/test/desugarPackage.scala
new file mode 100644
index 000000000..9fb5eb6ec
--- /dev/null
+++ b/test/test/desugarPackage.scala
@@ -0,0 +1,27 @@
+package test
+
+import dotty.tools.dotc._
+import core._, ast._
+import Trees._
+
+object desugarPackage extends DeSugarTest {
+
+  def test() = {
+    reset()
+    val start = System.nanoTime()
+    val startNodes = Trees.ntrees
+    parseDir("/Users/odersky/workspace/dotty/src")
+    parseDir("/Users/odersky/workspace/scala/src")
+    val ms1 = (System.nanoTime() - start)/1000000
+    val nodes = Trees.ntrees
+    val buf = parsedTrees map desugarTree
+    val ms2 = (System.nanoTime() - start)/1000000
+    println(s"$parsed files parsed in ${ms1}ms, ${nodes - startNodes} nodes desugared in ${ms2-ms1}ms, total trees created = ${Trees.ntrees - startNodes}")
+    ctx.reporter.printSummary(ctx)
+  }
+
+  def main(args: Array[String]): Unit = {
+//    parse("/Users/odersky/workspace/scala/src/compiler/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala")
+    for (i <- 0 until 10) test()
+  }
+}
\ No newline at end of file
diff --git a/test/test/desugarTests.scala b/test/test/desugarTests.scala
new file mode 100644
index 000000000..25f2e5624
--- /dev/null
+++ b/test/test/desugarTests.scala
@@ -0,0 +1,36 @@
+package test
+
+import scala.reflect.io._
+import dotty.tools.dotc.util._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.parsing._
+import Tokens._, Parsers._
+import dotty.tools.dotc.ast.untpd._
+import org.junit.Test
+import scala.collection.mutable.ListBuffer
+
+class desugarTests extends DeSugarTest {
+
+  @Test
+  def parseList(): Unit = {
+    println(System.getProperty("user.dir"))
+    parse("src/dotty/tools/dotc/core/Symbols.scala")
+    parse("src/dotty/tools/dotc/core/Types.scala")
+    desugarAll()
+    reset()
+  }
+
+  @Test
+  def parseDotty(): Unit = {
+    parseDir("src")
+    desugarAll()
+    reset()
+  }
+
+  @Test
+  def parseScala() = {
+    parseDir("/Users/odersky/workspace/scala/src")
+    desugarAll()
+    reset()
+  }
+}
\ No newline at end of file
diff --git a/test/test/parserTests.scala b/test/test/parserTests.scala
new file mode 100644
index 000000000..7f337bc1a
--- /dev/null
+++ b/test/test/parserTests.scala
@@ -0,0 +1,34 @@
+package test
+
+import scala.reflect.io._
+import dotty.tools.dotc.util._
+import dotty.tools.dotc.core._
+import dotty.tools.dotc.parsing._
+import Tokens._, Parsers._
+import dotty.tools.dotc.ast.untpd._
+import org.junit.Test
+import scala.collection.mutable.ListBuffer
+
+class parserTests extends ParserTest {
+
+  @Test
+  def parseList(): Unit = {
+    println(System.getProperty("user.dir"))
+    parse("src/dotty/tools/dotc/core/Symbols.scala")
+    parse("src/dotty/tools/dotc/core/Types.scala")
+    reset()
+  }
+
+  @Test
+  def parseDotty(): Unit = {
+    parseDir("src")
+    reset()
+  }
+
+  @Test
+  def parseScala() = {
+    parseDir("/Users/odersky/workspace/scala/src")
+    reset()
+  }
+
+}
\ No newline at end of file
diff --git a/test/test/showTree.scala b/test/test/showTree.scala
index 605f05922..69530a046 100644
--- a/test/test/showTree.scala
+++ b/test/test/showTree.scala
@@ -1,18 +1,64 @@
 package test
-import dotty.tools.dotc.ast.untpd._
+import dotty.tools.dotc._
+import ast.Trees._
 
 object showTree extends ParserTest {
 
+  import dotty.tools.dotc.ast.untpd._
+
+  import Mode._
+
   object DeSugar extends TreeTransformer {
-    override def transform(tree: Tree) = {
-      val tree1 = desugar(tree, Mode.Expr)
+    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}")
+        //println(s"repeat desugar ${tree1.getClass}")
         transform(tree1)
       }
       else tree1 match {
-        case PostfixOp(od, op) => PostfixOp(transform(od), op)
-        case tree1 => super.transform(tree1)
+        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, tparams, impl) =>
+          tree1.derivedClassDef(mods, name, transformSub(tparams), transformSub(impl))
+        case tree1 =>
+          super.transform(tree1)
       }
     }
   }