diff options
Diffstat (limited to 'compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala')
-rw-r--r-- | compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala | 96 |
1 files changed, 96 insertions, 0 deletions
diff --git a/compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala b/compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala new file mode 100644 index 000000000..1f79c2cf6 --- /dev/null +++ b/compiler/test/dotty/tools/dotc/parsing/DeSugarTest.scala @@ -0,0 +1,96 @@ +package dotty.tools +package dotc +package parsing + +import Tokens._, Parsers._ +import scala.reflect.io._ +import util._ +import core._ +import ast.Trees._ +import ast.desugar +import ast.desugar._ +import core.Mode +import Contexts.Context + +import scala.collection.mutable.ListBuffer + +class DeSugarTest extends ParserTest { + + import dotty.tools.dotc.ast.untpd._ + + import Mode._ + + val Expr = Mode(0) + + object DeSugar extends UntypedTreeMap { + var curMode: Mode = Expr + def withMode[T](mode: Mode)(op: => T) = { + val saved = curMode + curMode = mode + try op + finally curMode = saved + } + + def transform(tree: Tree, mode: Mode)(implicit ctx: Context): Tree = withMode(mode) { transform(tree) } + def transform(trees: List[Tree], mode: Mode)(implicit ctx: Context): List[Tree] = withMode(mode) { transform(trees) } + + override def transform(tree: Tree)(implicit ctx: Context): Tree = { + val tree1 = desugar(tree)(ctx.withModeBits(curMode)) + tree1 match { + case TypedSplice(t) => + tree1 + case PostfixOp(od, op) => + PostfixOp(transform(od), op) + case Select(qual, name) => + cpy.Select(tree1)(transform(qual, Expr), name) + case Apply(fn, args) => + cpy.Apply(tree1)(transform(fn, Expr), transform(args)) + case TypeApply(fn, args) => + cpy.TypeApply(tree1)(transform(fn, Expr), transform(args, Type)) + case New(tpt) => + cpy.New(tree1)(transform(tpt, Type)) + case Typed(expr, tpt) => + cpy.Typed(tree1)(transform(expr), transform(tpt, Type)) + case CaseDef(pat, guard, body) => + cpy.CaseDef(tree1)(transform(pat, Pattern), transform(guard), transform(body)) + case SeqLiteral(elems, elemtpt) => + cpy.SeqLiteral(tree1)(transform(elems), transform(elemtpt)) + case UnApply(fun, implicits, patterns) => + cpy.UnApply(tree1)(transform(fun, Expr), transform(implicits), transform(patterns)) + case tree1 @ ValDef(name, tpt, _) => + cpy.ValDef(tree1)(name, transform(tpt, Type), transform(tree1.rhs)) + case tree1 @ DefDef(name, tparams, vparamss, tpt, _) => + cpy.DefDef(tree1)(name, transformSub(tparams), vparamss mapConserve (transformSub(_)), transform(tpt, Type), transform(tree1.rhs)) + case tree1 @ TypeDef(name, rhs) => + cpy.TypeDef(tree1)(name, transform(rhs, Type)) + case impl @ Template(constr, parents, self, _) => + cpy.Template(tree1)(transformSub(constr), transform(parents), transformSub(self), transform(impl.body, Expr)) + case Thicket(trees) => + Thicket(flatten(trees mapConserve super.transform)) + case tree1 => + super.transform(tree1) + } + } + } + + def firstClass(stats: List[Tree]): String = stats match { + case Nil => "<empty>" + case TypeDef(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) +} |