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
|
// RUN: %target-run-simple-swift
// RUN: %target-run-simple-swift(-Xfrontend -disable-reflection-metadata)
// RUN: %target-run-simple-swift(-Xfrontend -reflection-metadata-for-debugger-only)
// RUN: %target-run-simple-swift(-Xfrontend -disable-reflection-names)
//
// REQUIRES: executable_test
import StdlibUnittest
var tests = TestSuite("MetadataPruning")
struct TestStruct {
var int = 0
var double = 0.0
var bool = false
}
struct GenericStruct<T> {
var int = 0
var first: T
var second: T
}
enum TestEnum {
case one
case two
case three(TestStruct)
}
class BaseClass {
var superInt = 0
init() {}
}
class TestClass: BaseClass {
var int = 0
var double = 0.0
var bool = false
override init() {}
}
class TestSubclass: TestClass {
var strings: [String] = []
override init() {}
}
class GenericClass<T, U>: BaseClass {
var first: T
var second: U
init(_ t: T, _ u: U) {
self.first = t
self.second = u
}
}
class GenericSubclass<V, W>: GenericClass<V, Bool> {
var third: W
init(_ v: V, _ w: W) {
self.third = w
super.init(v, false)
}
}
class OwnershipTestClass: BaseClass {
weak var test1: TestClass?
unowned var test2: TestClass
unowned(unsafe) var test3: TestClass
init(_ t: TestClass) {
self.test1 = t
self.test2 = t
self.test3 = t
}
}
struct ContainsObject {
var obj: TestClass
}
#if _runtime(_ObjC)
import Foundation
class NSObjectSubclass: NSObject {
var point: (Double, Double)
init(x: Double, y: Double) {
self.point = (x, y)
}
}
class EmptyNSObject: NSObject {}
#endif
func printAddress(_ obj: AnyObject) {
print("\(obj) address: \(Unmanaged.passUnretained(obj).toOpaque())")
}
tests.test("Allocate types without metadata") {
let testStruct = TestStruct()
let genericStruct = GenericStruct<Double>(first: 1.3, second: 3.7)
let testEnum = TestEnum.three(testStruct)
let baseClass = BaseClass()
let testClass = TestClass()
let testSubclass = TestSubclass()
let genericClass = GenericClass<Int, String>(5, "bla")
let genericSubclass = GenericSubclass<Double, TestClass>(1.1, testClass)
let ownershipTestClass = OwnershipTestClass(testClass)
let containsObject = ContainsObject(obj: testClass)
print("\(testStruct)")
print("\(genericStruct)")
print("\(testEnum)")
printAddress(baseClass)
printAddress(testClass)
printAddress(testSubclass)
printAddress(genericClass)
printAddress(genericSubclass)
printAddress(ownershipTestClass)
print("\(containsObject)")
#if _runtime(_ObjC)
let nsObjectSubclass = NSObjectSubclass(x: 1.2, y: 3.4)
let emptyNSObject = EmptyNSObject()
printAddress(nsObjectSubclass)
printAddress(emptyNSObject)
#endif
}
runAllTests()
|
