blob: 9c3ea7f0133960d7e497725aed3d7bf6fbcc4a72 (
plain) (
blame)
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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
class A1 {
class B
}
class A2 {
object B
}
object A3 {
class B1
object B2
}
class A4 {
def f(l: List[Int]): List[Int] = {
l map (_ + 1)
}
}
class A5 {
def f(): Object = {
object B
B
}
}
trait A6 {
def hui = -6
trait TT
}
class A7 extends A6
abstract class A8 extends A6 {
def fish: TT
}
class A9 {
class brick extends annotation.StaticAnnotation
}
class A10 {
val a9 = new A9()
// there's no reference to brick in the bytecode (only in the pickle), so there's no InnerClass attribute for it.
@a9.brick def f = -7
}
class A11 {
@JavaAnnot_1.Ann def f = -8
}
object A12 {
object B {
class C
}
}
class A13 {
def oak: A12.B.C = new A12.B.C
}
class A14 {
def f = {
val x: Object = {
class K
new K
}
x
}
def g = {
val x: Object = new A6 { }
}
}
object A15 {
def f = {
class B { // non-static, even though it doesn't have an outer pointer
class C // non-static
}
}
}
class A16 {
val x: A6 = {
class U extends A6
new A6 { }
}
{
class V extends A6
new A6 { }
}
new A6 { }
}
class A17 {
object B {
class C // not static, also has an outer pointer.
}
}
class A18 {
def f = {
def g = {
class A
new A6 { }
val y = {
if ((new Object).hashCode() == 1) {class B {} ; new B} else 2
if ((new Object).hashCode() == 1) new A6 { } else "haifish"
}
}
}
}
class A19 {
((x: Int) => x + 3)
val x = {
((x: Int) => x + 1)
}
{
((x: Int) => x + 2)
}
}
class A20 {
() => {
{() => ()}
{() => () => 1}
}
}
class A21 {
class I1
def f = { class J1 }
}
object A21 {
class I2
object I3 {
class J2 // static
}
def g = { class J3 } // non-static
val x = { class J4 } // non-static
{
class J5 // non-static (!)
new J5
}
}
class A22 {
class C
object C {
class D // inner class of C$, not of C. Not added to the inner class table of C, only to C$
}
}
class A23 {
def f = {
val a = new Java_A_1()
val c = new Java_A_1.C()
val d = new Java_A_1.C.D()
val e = new c.E()
val f = new a.F()
val g = new f.G()
}
}
trait A24Sym
trait A24Base {
// trait with concrete members: interface plus (absract) impl class
trait DefinitionsApi {
def Abs: A24Sym
def Conc: A24Sym = new A24Sym { }
}
}
trait A24 extends A24Base {
class DefinitionsClass extends DefinitionsApi {
// bridge methods are generated for Abs and Conc. there used to be a bug: the bridge symbol was a ModuleSymbol,
// calling companionClass would return NoSymbol. i changed erasure to make the bridge symbol is a MethodSymbol.
object Abs extends A24Sym
override object Conc extends A24Sym
}
}
|
