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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
trait A {
lazy val z1 = {
println("<forced z1>")
"lazy z1"
}
}
/** Simple class which mixes in one lazy val. */
class Cls extends AnyRef with A {
override def toString =
"z1 = " + z1
}
/** Own lazy val + one mixed in. */
class Cls2 extends AnyRef with A {
lazy val z2 = {
println("<forced z2>")
"lazy z2"
}
override def toString =
"z1 = " + z1 + " z2 = " + z2
}
trait B extends A {
lazy val zb1 = {
println("<forced zb1>")
"lazy zb1"
}
}
class ClsB extends Object with B {
lazy val zc1 = {
println("<forced zc1>")
"lazy zc1"
}
override def toString =
"z1 = " + z1 + " zb1 = " + zb1 + " zc1 = " + zc1
}
/** Class with 32 lazy fields mixes in one more. */
class OverflownLazyFields extends Object with A {
lazy val zc00 = { println("<forced zc00>"); "lazy zc00" }
lazy val zc01 = { println("<forced zc01>"); "lazy zc01" }
lazy val zc02 = { println("<forced zc02>"); "lazy zc02" }
lazy val zc03 = { println("<forced zc03>"); "lazy zc03" }
lazy val zc04 = { println("<forced zc04>"); "lazy zc04" }
lazy val zc05 = { println("<forced zc05>"); "lazy zc05" }
lazy val zc06 = { println("<forced zc06>"); "lazy zc06" }
lazy val zc07 = { println("<forced zc07>"); "lazy zc07" }
lazy val zc08 = { println("<forced zc08>"); "lazy zc08" }
lazy val zc09 = { println("<forced zc09>"); "lazy zc09" }
lazy val zc10 = { println("<forced zc10>"); "lazy zc10" }
lazy val zc11 = { println("<forced zc11>"); "lazy zc11" }
lazy val zc12 = { println("<forced zc12>"); "lazy zc12" }
lazy val zc13 = { println("<forced zc13>"); "lazy zc13" }
lazy val zc14 = { println("<forced zc14>"); "lazy zc14" }
lazy val zc15 = { println("<forced zc15>"); "lazy zc15" }
lazy val zc16 = { println("<forced zc16>"); "lazy zc16" }
lazy val zc17 = { println("<forced zc17>"); "lazy zc17" }
lazy val zc18 = { println("<forced zc18>"); "lazy zc18" }
lazy val zc19 = { println("<forced zc19>"); "lazy zc19" }
lazy val zc20 = { println("<forced zc20>"); "lazy zc20" }
lazy val zc21 = { println("<forced zc21>"); "lazy zc21" }
lazy val zc22 = { println("<forced zc22>"); "lazy zc22" }
lazy val zc23 = { println("<forced zc23>"); "lazy zc23" }
lazy val zc24 = { println("<forced zc24>"); "lazy zc24" }
lazy val zc25 = { println("<forced zc25>"); "lazy zc25" }
lazy val zc26 = { println("<forced zc26>"); "lazy zc26" }
lazy val zc27 = { println("<forced zc27>"); "lazy zc27" }
lazy val zc28 = { println("<forced zc28>"); "lazy zc28" }
lazy val zc29 = { println("<forced zc29>"); "lazy zc29" }
lazy val zc30 = { println("<forced zc30>"); "lazy zc30" }
lazy val zc31 = { println("<forced zc31>"); "lazy zc31" }
override def toString =
"\nzc00 = " + zc00 +
"\nzc01 = " + zc01 +
"\nzc02 = " + zc02 +
"\nzc03 = " + zc03 +
"\nzc04 = " + zc04 +
"\nzc05 = " + zc05 +
"\nzc06 = " + zc06 +
"\nzc07 = " + zc07 +
"\nzc08 = " + zc08 +
"\nzc09 = " + zc09 +
"\nzc10 = " + zc10 +
"\nzc11 = " + zc11 +
"\nzc12 = " + zc12 +
"\nzc13 = " + zc13 +
"\nzc14 = " + zc14 +
"\nzc15 = " + zc15 +
"\nzc16 = " + zc16 +
"\nzc17 = " + zc17 +
"\nzc18 = " + zc18 +
"\nzc19 = " + zc19 +
"\nzc20 = " + zc20 +
"\nzc21 = " + zc21 +
"\nzc22 = " + zc22 +
"\nzc23 = " + zc23 +
"\nzc24 = " + zc24 +
"\nzc25 = " + zc25 +
"\nzc26 = " + zc26 +
"\nzc27 = " + zc27 +
"\nzc28 = " + zc28 +
"\nzc29 = " + zc29 +
"\nzc30 = " + zc30 +
"\nzc31 = " + zc31 +
"\nz1 = " + z1
}
trait PrivateLazy {
private lazy val str = "z1"
}
/** Test successful compilation. */
class InheritPrivateLazy extends AnyRef with PrivateLazy {}
/** Test successful compilation, see bug #1287. */
trait LocalLazyVal {
def foo = {
lazy val next = 10 + 1
next
}
}
/** Test successful compilation (see ticket #39) */
package x.y {
trait Trait {
lazy val v = 1
}
class OuterClass {
object InnerObject extends Trait
}
}
/** Test successful compilation of lazy values of type Unit. */
class UnitLazy extends A {
lazy val lz = Console.println("UnitLazy.lz forced")
}
trait UnitLazyT {
lazy val lzt = Console.println("UnitLazyT.lzt forced")
}
class MixedUnitLazy extends UnitLazy with UnitLazyT {
override def toString() = {
lz
lzt
"MixedUnitLazy"
}
}
object Test extends App {
def test(name: String, v: A) {
println(name + " test:")
println(v)
println(v)
println(v)
}
test("Cls", new Cls)
test("Cls2", new Cls2)
test("Cls with B", new ClsB)
test("OverflownLazyFields with A", new OverflownLazyFields)
test("Unit lazy values", new MixedUnitLazy)
}
|
