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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
package dotty.tools
package dotc
package transform
import org.junit.{Assert, Test}
import core._
import ast.{tpd, Trees}
import Contexts._
import Flags._
import Denotations._
import NameOps._
import Symbols._
import Types._
import Decorators._
import Trees._
import TreeTransforms.{TreeTransform, TreeTransformer}
class CreateCompanionObjectsTest extends DottyTest {
/* FIXME: re-enable after adapting to new scheme
import tpd._
type PostTyperTransformer = TreeTransformer // FIXME do without
@Test
def shouldCreateNonExistingObjectsInPackage = checkCompile("frontend", "class A{} ") {
(tree, context) =>
implicit val ctx = context
val transformer = new PostTyperTransformer {
override def transformations = Array(new CreateCompanionObjects {
override def name: String = "create all companion objects"
override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
})
override def name: String = "test"
}
val transformed = transformer.transform(tree).toString
val classPattern = "TypeDef(Modifiers(,,List()),A,"
val classPos = transformed.indexOf(classPattern)
val moduleClassPattern = "TypeDef(Modifiers(final module <synthetic>,,List()),A$"
val modulePos = transformed.indexOf(moduleClassPattern)
Assert.assertTrue("should create non-existing objects in package",
classPos < modulePos
)
}
@Test
def shouldCreateNonExistingObjectsInBlock = checkCompile("frontend", "class D {def p = {class A{}; 1}} ") {
(tree, context) =>
implicit val ctx = context
val transformer = new PostTyperTransformer {
override def transformations = Array(new CreateCompanionObjects {
override def name: String = "create all companion modules"
override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
})
override def name: String = "test"
}
val transformed = transformer.transform(tree).toString
val classPattern = "TypeDef(Modifiers(,,List()),A,"
val classPos = transformed.indexOf(classPattern)
val moduleClassPattern = "TypeDef(Modifiers(final module <synthetic>,,List()),A$"
val modulePos = transformed.indexOf(moduleClassPattern)
Assert.assertTrue("should create non-existing objects in block",
classPos < modulePos
)
}
@Test
def shouldCreateNonExistingObjectsInTemplate = checkCompile("frontend", "class D {class A{}; } ") {
(tree, context) =>
implicit val ctx = context
val transformer = new PostTyperTransformer {
override def transformations = Array(new CreateCompanionObjects {
override def name: String = "create all companion modules"
override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = true
init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
})
override def name: String = "test"
}
val transformed = transformer.transform(tree).toString
val classPattern = "TypeDef(Modifiers(,,List()),A,"
val classPos = transformed.indexOf(classPattern)
val moduleClassPattern = "TypeDef(Modifiers(final module <synthetic>,,List()),A$"
val modulePos = transformed.indexOf(moduleClassPattern)
Assert.assertTrue("should create non-existing objects in template",
classPos < modulePos
)
}
@Test
def shouldCreateOnlyIfAskedFor = checkCompile("frontend", "class DONT {class CREATE{}; } ") {
(tree, context) =>
implicit val ctx = context
val transformer = new PostTyperTransformer {
override def transformations = Array(new CreateCompanionObjects {
override def name: String = "create all companion modules"
override def predicate(cts: TypeDef)(implicit ctx:Context): Boolean = cts.name.toString.contains("CREATE")
init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
})
override def name: String = "test"
}
val transformed = transformer.transform(tree).toString
val classPattern = "TypeDef(Modifiers(,,List()),A,"
val classPos = transformed.indexOf(classPattern)
val moduleClassPattern = "TypeDef(Modifiers(final module <synthetic>,,List()),CREATE$"
val modulePos = transformed.indexOf(moduleClassPattern)
val notCreatedModulePattern = "TypeDef(Modifiers(final module <synthetic>,,List()),DONT"
val notCreatedPos = transformed.indexOf(notCreatedModulePattern)
Assert.assertTrue("should create non-existing objects in template",
classPos < modulePos && (notCreatedPos < 0)
)
}
*/
}
|
