1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
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)
}
|
