From 9d6a5299d01a3a808d060396ef1f10a693a1bdae Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 24 May 2013 16:42:35 +0200 Subject: Added tests for desugaring. --- test/test/DeSugarTest.scala | 95 ++++++++++++++++++++++++++++++++++++++++++ test/test/ParserTest.scala | 18 -------- test/test/desugarPackage.scala | 27 ++++++++++++ test/test/desugarTests.scala | 36 ++++++++++++++++ test/test/parserTests.scala | 34 +++++++++++++++ test/test/showTree.scala | 58 +++++++++++++++++++++++--- 6 files changed, 244 insertions(+), 24 deletions(-) create mode 100644 test/test/DeSugarTest.scala create mode 100644 test/test/desugarPackage.scala create mode 100644 test/test/desugarTests.scala create mode 100644 test/test/parserTests.scala (limited to 'test') 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 => "" + 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) } } } -- cgit v1.2.3