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
|
struct __attribute__((swift_attr("import_unsafe"))) NonTrivial {
NonTrivial() {}
NonTrivial(const NonTrivial &) {}
~NonTrivial() {}
inline const char *inNonTrivial() const
__attribute__((swift_attr("import_unsafe"))) {
return "NonTrivial::inNonTrivial";
}
inline const char *inNonTrivialWithArgs(int a, int b) const
__attribute__((swift_attr("import_unsafe"))) {
return "NonTrivial::inNonTrivialWithArgs";
}
};
struct Base {
inline const char *mutatingInBase()
__attribute__((swift_attr("import_unsafe"))) {
return "Base::mutatingInBase";
}
inline const char *constInBase() const
__attribute__((swift_attr("import_unsafe"))) {
return "Base::constInBase";
}
inline const char *rvalueThisInBase() const&&
__attribute__((swift_attr("import_unsafe"))) {
return "Base::rvalueThisInBase";
}
// TODO: if these are unnamed we hit an (unrelated) SILGen bug. Same for
// subscripts.
inline const char *takesArgsInBase(int a, int b, int c) const
__attribute__((swift_attr("import_unsafe"))) {
return "Base::takesArgsInBase";
}
inline const char *takesNonTrivialInBase(NonTrivial a) const
__attribute__((swift_attr("import_unsafe"))) {
return "Base::takesNonTrivialInBase";
}
inline NonTrivial returnsNonTrivialInBase() const { return NonTrivial{}; }
template <class T>
inline const char *templateInBase(T t) const
__attribute__((swift_attr("import_unsafe"))) {
return "Base::templateInBase";
}
static const char *staticInBase()
__attribute__((swift_attr("import_unsafe"))) {
return "Base::staticInBase";
}
int renamed(int i) __attribute__((swift_name("swiftRenamed(input:)"))) {
return i * 2;
}
void pure() const __attribute__((pure)) {}
inline int sameMethodNameSameSignature() const {
return 42;
}
inline int sameMethodDifferentSignature() const {
return 18;
}
};
struct OtherBase {
inline const char *inOtherBase() const
__attribute__((swift_attr("import_unsafe"))) {
return "OtherBase::inOtherBase";
}
// TODO: test private access
};
struct Derived : Base, OtherBase {
inline const char *inDerived() const
__attribute__((swift_attr("import_unsafe"))) {
return "Derived::inDerived";
}
inline int sameMethodNameSameSignature() const {
return 21;
}
inline int sameMethodDifferentSignature(int x) const {
return x + 1;
}
};
struct DerivedFromDerived : Derived {
inline const char *topLevel() const
__attribute__((swift_attr("import_unsafe"))) {
return "DerivedFromDerived::topLevel";
}
};
struct __attribute__((swift_attr("import_unsafe"))) DerivedFromNonTrivial
: NonTrivial {};
struct PrivatelyInherited : private Base {
};
struct ProtectedInherited : protected Base {
};
struct EmptyBaseClass {
const char *inBase() const __attribute__((swift_attr("import_unsafe"))) {
return "EmptyBaseClass::inBase";
}
};
struct DerivedFromEmptyBaseClass : EmptyBaseClass {
int a = 42;
int b = 42;
};
int &getCopyCounter() {
static int copyCounter = 0;
return copyCounter;
}
class CopyTrackedBaseClass {
public:
CopyTrackedBaseClass(int x) : x(x) {}
CopyTrackedBaseClass(const CopyTrackedBaseClass &other) : x(other.x) {
++getCopyCounter();
}
int getX() const {
return x;
}
int getXMut() {
return x;
}
private:
int x;
};
class CopyTrackedDerivedClass: public CopyTrackedBaseClass {
public:
CopyTrackedDerivedClass(int x) : CopyTrackedBaseClass(x) {}
int getDerivedX() const {
return getX();
}
};
class NonEmptyBase {
public:
int getY() const {
return y;
}
private:
int y = 11;
};
class CopyTrackedDerivedDerivedClass: public NonEmptyBase, public CopyTrackedDerivedClass {
public:
CopyTrackedDerivedDerivedClass(int x) : CopyTrackedDerivedClass(x) {}
};
|
