Skip to content

Commit 5419a4c

Browse files
nicolasstuckinicolasstucki
committed
Implement TASTy reflect constructors
* Add tree constructors (apply in their module) * Add tree copier (copy in their module) * Add missing parameter of Term.Repeated * Add Term.Ref as a supertype of Term.Ident and Term.Select * Rename Project by Projection
1 parent fcc35d2 commit 5419a4c

File tree

22 files changed

+1047
-136
lines changed

22 files changed

+1047
-136
lines changed

‎compiler/src/dotty/tools/dotc/ast/Trees.scala‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -975,13 +975,13 @@ object Trees {
975975
* so that they selectively retype themselves. Retyping needs a context.
976976
*/
977977
abstract class TreeCopier {
978-
def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
979-
def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
978+
protected def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[T]
979+
protected def postProcess(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T]
980980

981-
def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
981+
protected def finalize(tree: Tree, copied: untpd.Tree): copied.ThisTree[T] =
982982
postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
983983

984-
def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
984+
protected def finalize(tree: Tree, copied: untpd.MemberDef): copied.ThisTree[T] =
985985
postProcess(tree, copied.withPos(tree.pos).withAttachmentsFrom(tree))
986986

987987
def Ident(tree: Tree)(name: Name): Ident = tree match {

‎compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
package dotty.tools.dotc.tastyreflect
22

3+
import dotty.tools.dotc.ast.tpd
34

45
trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with Helpers {
56

@@ -10,6 +11,12 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
1011
}
1112

1213
object CaseDef extends CaseDefModule {
14+
def apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef =
15+
tpd.CaseDef(pattern, guard.getOrElse(tpd.EmptyTree), body)
16+
17+
def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef =
18+
tpd.cpy.CaseDef(original)(pattern, guard.getOrElse(tpd.EmptyTree), body)
19+
1320
def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
1421
}
1522

@@ -19,6 +26,12 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
1926
}
2027

2128
object TypeCaseDef extends TypeCaseDefModule {
29+
def apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef =
30+
tpd.CaseDef(pattern, tpd.EmptyTree, body)
31+
32+
def copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef =
33+
tpd.cpy.CaseDef(original)(pattern, tpd.EmptyTree, body)
34+
2235
def unapply(x: TypeCaseDef): Some[(TypeTree, TypeTree)] = Some((x.pat, x.body))
2336
}
2437
}

‎compiler/src/dotty/tools/dotc/tastyreflect/CoreImpl.scala‎

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,9 @@ trait CoreImpl extends scala.tasty.reflect.Core {
2626
type Term = tpd.Tree
2727
val Term: TermCoreModuleImpl
2828
trait TermCoreModuleImpl extends TermCoreModule {
29-
type Ident = tpd.Ident
30-
type Select = tpd.Select
29+
type Ref = tpd.RefTree
30+
type Ident = tpd.Ident
31+
type Select = tpd.Select
3132
type Literal = tpd.Literal
3233
type This = tpd.This
3334
type New = tpd.New
@@ -56,8 +57,8 @@ trait CoreImpl extends scala.tasty.reflect.Core {
5657
type Pattern = tpd.Tree
5758
type Value = tpd.Tree
5859
type Bind = tpd.Bind
59-
type Unapply = tpd.Tree
60-
type Alternative = tpd.Alternative
60+
type Unapply = tpd.UnApply
61+
type Alternatives = tpd.Alternative
6162
type TypeTest = tpd.Typed
6263

6364
type TypeOrBoundsTree = tpd.Tree
@@ -67,7 +68,7 @@ trait CoreImpl extends scala.tasty.reflect.Core {
6768
type Inferred = tpd.TypeTree
6869
type Ident = tpd.Ident
6970
type Select = tpd.Select
70-
type Project = tpd.Select
71+
type Projection = tpd.Select
7172
type Singleton = tpd.SingletonTypeTree
7273
type Refined = tpd.RefinedTypeTree
7374
type Applied = tpd.AppliedTypeTree
@@ -77,8 +78,8 @@ trait CoreImpl extends scala.tasty.reflect.Core {
7778
type MatchType = tpd.MatchTypeTree
7879
type ByName = tpd.ByNameTypeTree
7980
type LambdaTypeTree = tpd.LambdaTypeTree
80-
type Bind = tpd.Bind
81-
type Block = tpd.Block
81+
type TypeBind = tpd.Bind
82+
type TypeBlock = tpd.Block
8283
}
8384
type TypeBoundsTree = tpd.TypeBoundsTree
8485
type WildcardType = tpd.TypeTree

‎compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala‎

Lines changed: 97 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,36 @@
11
package dotty.tools.dotc.tastyreflect
22

3-
import dotty.tools.dotc.ast.{Trees, tpd}
3+
import dotty.tools.dotc.ast.{Trees, tpd, untpd}
4+
import dotty.tools.dotc.core.Contexts
45
import dotty.tools.dotc.core.Decorators._
6+
import dotty.tools.dotc.core.StdNames.nme
57

68
trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
79

10+
def ValueDeco(value: Value): Pattern.ValueAPI = new Pattern.ValueAPI {
11+
def value(implicit ctx: Context): Term = value
12+
}
13+
def BindDeco(bind: Bind): Pattern.BindAPI = new Pattern.BindAPI {
14+
def name(implicit ctx: Context): String = bind.name.toString
15+
def pattern(implicit ctx: Context): Pattern = bind.body
16+
}
17+
def UnapplyDeco(unapply: Unapply): Pattern.UnapplyAPI = new Pattern.UnapplyAPI {
18+
def fun(implicit ctx: Context): Term = unapply.fun
19+
def implicits(implicit ctx: Context): List[Term] = unapply.implicits
20+
def patterns(implicit ctx: Context): List[Pattern] = effectivePatterns(unapply.patterns)
21+
22+
private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match {
23+
case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems
24+
case _ => patterns
25+
}
26+
}
27+
def AlternativeDeco(alternatives: Alternatives): Pattern.AlternativesAPI = new Pattern.AlternativesAPI {
28+
def patterns(implicit ctx: Context): List[Pattern] = alternatives.trees
29+
}
30+
def TypeTestDeco(typeTest: TypeTest): Pattern.TypeTestAPI = new Pattern.TypeTestAPI {
31+
def tpt(implicit ctx: Context): TypeTree = typeTest.tpt
32+
}
33+
834
// ----- Patterns -------------------------------------------------
935

1036
def PatternDeco(pattern: Pattern): PatternAPI = new PatternAPI {
@@ -14,45 +40,104 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
1440

1541
object Pattern extends PatternModule {
1642

17-
object Value extends ValueModule {
18-
def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = x match {
43+
object IsValue extends IsValueModule {
44+
def unapply(pattern: Pattern)(implicit ctx: Context): Option[Value] = pattern match {
1945
case lit: tpd.Literal => Some(lit)
2046
case ref: tpd.RefTree if ref.isTerm => Some(ref)
2147
case ths: tpd.This => Some(ths)
2248
case _ => None
2349
}
2450
}
2551

52+
object Value extends ValueModule {
53+
def apply(term: Term)(implicit ctx: Context): Value = term match {
54+
case lit: tpd.Literal => lit
55+
case ref: tpd.RefTree if ref.isTerm => ref
56+
case ths: tpd.This => ths
57+
}
58+
def copy(original: Value)(term: Term)(implicit ctx: Context): Value = term match {
59+
case lit: tpd.Literal => tpd.cpy.Literal(original)(lit.const)
60+
case ref: tpd.RefTree if ref.isTerm => tpd.cpy.Ref(original.asInstanceOf[tpd.RefTree])(ref.name)
61+
case ths: tpd.This => tpd.cpy.This(original)(ths.qual)
62+
}
63+
def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = IsValue.unapply(x)
64+
}
65+
66+
object IsBind extends IsBindModule {
67+
def unapply(x: Pattern)(implicit ctx: Context): Option[Bind] = x match {
68+
case x: tpd.Bind if x.name.isTermName => Some(x)
69+
case _ => None
70+
}
71+
}
72+
2673
object Bind extends BindModule {
27-
def unapply(x: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = x match {
28-
case x: tpd.Bind if x.name.isTermName => Some(x.name.toString, x.body)
74+
75+
def copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind =
76+
tpd.cpy.Bind(original)(name.toTermName, pattern)
77+
78+
def unapply(pattern: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = pattern match {
79+
case IsBind(pattern) => Some((pattern.name.toString, pattern.body))
80+
case _ => None
81+
}
82+
}
83+
84+
object IsUnapply extends IsUnapplyModule {
85+
def unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply] = pattern match {
86+
case pattern @ Trees.UnApply(_, _, _) => Some(pattern)
87+
case Trees.Typed(pattern @ Trees.UnApply(_, _, _), _) => Some(pattern)
2988
case _ => None
3089
}
3190
}
3291

3392
object Unapply extends UnapplyModule {
93+
94+
def copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply =
95+
tpd.cpy.UnApply(original)(fun, implicits, patterns)
96+
3497
def unapply(x: Pattern)(implicit ctx: Context): Option[(Term, List[Term], List[Pattern])] = x match {
35-
case Trees.UnApply(fun, implicits, patterns) => Some((fun, implicits, effectivePatterns(patterns)))
36-
case Trees.Typed(Trees.UnApply(fun, implicits, patterns), _) => Some((fun, implicits, effectivePatterns(patterns)))
98+
case IsUnapply(x) => Some((x.fun, x.implicits, UnapplyDeco(x).patterns))
3799
case _ => None
38100
}
39-
private def effectivePatterns(patterns: List[Pattern]): List[Pattern] = patterns match {
40-
case patterns0 :+ Trees.SeqLiteral(elems, _) => patterns0 ::: elems
41-
case _ => patterns
101+
}
102+
103+
object IsAlternatives extends IsAlternativesModule {
104+
def unapply(pattern: Pattern)(implicit ctx: Context): Option[Alternatives] = pattern match {
105+
case pattern: tpd.Alternative => Some(pattern)
106+
case _ => None
42107
}
43108
}
44109

45-
object Alternative extends AlternativeModule {
110+
object Alternatives extends AlternativesModule {
111+
def apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives =
112+
tpd.Alternative(patterns)
113+
114+
def copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives =
115+
tpd.cpy.Alternative(original)(patterns)
116+
46117
def unapply(x: Pattern)(implicit ctx: Context): Option[List[Pattern]] = x match {
47118
case x: tpd.Alternative => Some(x.trees)
48119
case _ => None
49120
}
50121
}
51122

123+
object IsTypeTest extends IsTypeTestModule {
124+
def unapply(pattern: Pattern)(implicit ctx: Context): Option[TypeTest] = pattern match {
125+
case Trees.Typed(_: tpd.UnApply, _) => None
126+
case pattern: tpd.Typed => Some(pattern)
127+
case _ => None
128+
}
129+
}
130+
52131
object TypeTest extends TypeTestModule {
132+
def apply(tpt: TypeTree)(implicit ctx: Context): TypeTest =
133+
tpd.Typed(untpd.Ident(nme.WILDCARD).withType(tpt.tpe), tpt)
134+
135+
def copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest =
136+
tpd.cpy.Typed(original)(untpd.Ident(nme.WILDCARD).withType(tpt.tpe), tpt)
137+
53138
def unapply(x: Pattern)(implicit ctx: Context): Option[TypeTree] = x match {
54139
case Trees.Typed(Trees.UnApply(_, _, _), _) => None
55-
case Trees.Typed(_, tpt) => Some(tpt)
140+
case Trees.Typed(expr, tpt) => Some(tpt)
56141
case _ => None
57142
}
58143
}

0 commit comments

Comments
 (0)