1 /*
2 REQUIRED_ARGS: -HC -c -o-
3 PERMUTE_ARGS:
4 TEST_OUTPUT:
5 ---
6 // Automatically generated by Digital Mars D Compiler
7 
8 #pragma once
9 
10 #include <assert.h>
11 #include <stddef.h>
12 #include <stdint.h>
13 #include <math.h>
14 
15 #ifdef CUSTOM_D_ARRAY_TYPE
16 #define _d_dynamicArray CUSTOM_D_ARRAY_TYPE
17 #else
18 /// Represents a D [] array
19 template<typename T>
20 struct _d_dynamicArray final
21 {
22     size_t length;
23     T *ptr;
24 
25     _d_dynamicArray() : length(0), ptr(NULL) { }
26 
27     _d_dynamicArray(size_t length_in, T *ptr_in)
28         : length(length_in), ptr(ptr_in) { }
29 
30     T& operator[](const size_t idx) {
31         assert(idx < length);
32         return ptr[idx];
33     }
34 
35     const T& operator[](const size_t idx) const {
36         assert(idx < length);
37         return ptr[idx];
38     }
39 };
40 #endif
41 
42 typedef uint$?:32=32|64=64$_t size_t;
43 
44 struct Outer final
45 {
46     int32_t a;
47     struct Member final
48     {
49         typedef int32_t Nested;
50         Member()
51         {
52         }
53     };
54 
55     Outer() :
56         a()
57     {
58     }
59     Outer(int32_t a) :
60         a(a)
61         {}
62 };
63 
64 enum : int32_t { SomeOtherLength = 1 };
65 
66 struct ActualBuffer final
67 {
68     ActualBuffer()
69     {
70     }
71 };
72 
73 template <typename T>
74 struct A final
75 {
76     // Ignoring var x alignment 0
77     T x;
78     // Ignoring var Enum alignment 0
79     enum : int32_t { Enum = 42 };
80 
81     // Ignoring var GsharedNum alignment 0
82     static int32_t GsharedNum;
83     // Ignoring var MemNum alignment 0
84     const int32_t MemNum;
85     void foo();
86     A()
87     {
88     }
89 };
90 
91 template <typename T>
92 struct NotInstantiated final
93 {
94     // Ignoring var noInit alignment 0
95     // Ignoring var missingSem alignment 0
96     NotInstantiated()
97     {
98     }
99 };
100 
101 struct B final
102 {
103     A<int32_t > x;
104     B() :
105         x()
106     {
107     }
108     B(A<int32_t > x) :
109         x(x)
110         {}
111 };
112 
113 template <typename T>
114 struct Foo final
115 {
116     // Ignoring var val alignment 0
117     T val;
118     Foo()
119     {
120     }
121 };
122 
123 template <typename T>
124 struct Bar final
125 {
126     // Ignoring var v alignment 0
127     Foo<T > v;
128     Bar()
129     {
130     }
131 };
132 
133 template <typename T>
134 struct Array final
135 {
136     typedef Array This;
137     typedef typeof(1 + 2) Int;
138     typedef typeof(T::a) IC;
139     Array(size_t dim);
140     ~Array();
141     void get() const;
142     template <typename T>
143     bool opCast() const;
144     // Ignoring var i alignment 0
145     typename T::Member i;
146     // Ignoring var j alignment 0
147     typename Outer::Member::Nested j;
148     void visit(typename T::Member::Nested i);
149     Array()
150     {
151     }
152 };
153 
154 template <typename T, typename U>
155 extern T foo(U u);
156 
157 extern A<A<int32_t > > aaint;
158 
159 template <typename T>
160 class Parent
161 {
162     // Ignoring var parentMember alignment 0
163 public:
164     T parentMember;
165     void parentFinal();
166     virtual void parentVirtual();
167 };
168 
169 template <typename T>
170 class Child final : public Parent<T >
171 {
172     // Ignoring var childMember alignment 0
173 public:
174     T childMember;
175     void parentVirtual();
176     T childFinal();
177 };
178 
179 extern void withDefTempl(A<int32_t > a = A<int32_t >(2, 13));
180 
181 template <typename T>
182 extern void withDefTempl2(A<T > a = static_cast<A<T >>(A<T >(2)));
183 
184 class ChildInt : public Parent<int32_t >
185 {
186 };
187 
188 struct HasMixins final
189 {
190     void foo(int32_t t);
191     HasMixins()
192     {
193     }
194 };
195 
196 template <typename T>
197 struct HasMixinsTemplate final
198 {
199     void foo(T t);
200     HasMixinsTemplate()
201     {
202     }
203 };
204 
205 extern HasMixinsTemplate<bool > hmti;
206 
207 template <typename T>
208 struct NotAA final
209 {
210     // Ignoring var length alignment 0
211     enum : int32_t { length = 12 };
212 
213     // Ignoring var buffer alignment 0
214     T buffer[length];
215     // Ignoring var otherBuffer alignment 0
216     T otherBuffer[SomeOtherLength];
217     // Ignoring var calcBuffer alignment 0
218     T calcBuffer[foo(1)];
219     NotAA()
220     {
221     }
222 };
223 
224 template <typename Buffer>
225 struct BufferTmpl final
226 {
227     // Ignoring var buffer alignment 0
228     Buffer buffer;
229     // Ignoring var buffer2 alignment 0
230     Buffer buffer2;
231     BufferTmpl()
232     {
233     }
234 };
235 
236 struct ImportedBuffer final
237 {
238     typedef ActualBuffer Buffer;
239     ActualBuffer buffer2;
240     ImportedBuffer()
241     {
242     }
243 };
244 ---
245 */
246 
A(T)247 extern (C++) struct A(T)
248 {
249     T x;
250     enum Enum = 42;
251     __gshared GsharedNum = 43;
252     immutable MemNum = 13;
253     void foo() {}
254 }
255 
256 // Invalid declarations accepted because it's not instantiated
NotInstantiated(T)257 extern (C++) struct NotInstantiated(T)
258 {
259     enum T noInit;
260     enum missingSem = T.init;
261 }
262 
263 extern (C++) struct B
264 {
265     A!int x;
266 }
267 
268 // https://issues.dlang.org/show_bug.cgi?id=20604
269 extern(C++)
270 {
Foo(T)271     struct Foo (T)
272     {
273         T val;
274     }
275 
Bar(T)276     struct Bar (T)
277     {
278         Foo!T v;
279     }
280 }
281 
Array(T)282 extern (C++) struct Array(T)
283 {
284     alias This = typeof(this);
285     alias Int = typeof(1 + 2);
286     alias IC = typeof(T.a);
287 
288     this(size_t dim) pure nothrow {}
289     @disable this(this);
290     ~this() {}
291     void get() const {}
292 
293     bool opCast(T)() const pure nothrow @nogc @safe
294     if (is(T == bool))
295     {
296         return str.ptr !is null;
297     }
298 
299     T.Member i;
300     Outer.Member.Nested j;
301     void visit(T.Member.Nested i) {}
302 }
303 
304 struct Outer
305 {
306     int a;
307     static struct Member
308     {
309         alias Nested = int;
310     }
311 }
312 
313 // alias AO = Array!Outer;
314 
315 extern(C++) T foo(T, U)(U u) { return T.init; }
316 
317 extern(C++) __gshared A!(A!int) aaint;
318 
319 extern(C++) class Parent(T)
320 {
321     T parentMember;
322     final void parentFinal() {}
323     void parentVirtual() {}
324 }
325 
326 extern(C++) final class Child(T) : Parent!T
327 {
328     T childMember;
329     override void parentVirtual() {}
330     T childFinal() { return T.init; }
331 }
332 
333 extern(C++) void withDefTempl(A!int a = A!int(2)) {}
334 
335 extern(C++) void withDefTempl2(T)(A!T a = A!T(2)) {}
336 
337 extern(C++) alias withDefTempl2Inst = withDefTempl2!int;
338 
339 extern(C++) class ChildInt : Parent!int {}
340 
341 /******************************************************
342  * Mixins
343  */
344 
345 extern (C++):
346 
347 mixin template MixinA(T)
348 {
349     void foo(T t) {}
350 }
351 
352 mixin template MixinB() {}
353 
354 struct HasMixins
355 {
356     mixin MixinA!int;
357     mixin MixinB;
358 }
359 
360 struct HasMixinsTemplate(T)
361 {
362     mixin MixinA!T;
363     mixin MixinB;
364 }
365 
366 __gshared HasMixinsTemplate!bool hmti;
367 
368 /// Declarations that look like associative arrays
369 
370 extern(D) enum SomeOtherLength = 1;
371 
372 struct NotAA(T)
373 {
374     private:
375     enum length = 12;
376     public:
377     T[length] buffer;
378     T[SomeOtherLength] otherBuffer;
379     T[foo(1)] calcBuffer;
380 }
381 
382 // Same name but hidden by the template paramter
383 extern (D) struct Buffer {}
384 extern (D) struct ActualBuffer {}
385 
386 struct BufferTmpl(Buffer)
387 {
388     Buffer buffer;
389     mixin BufferMixin!();
390 }
391 
392 struct ImportedBuffer
393 {
394     alias Buffer = ActualBuffer;
395     mixin BufferMixin!();
396 }
397 
398 mixin template BufferMixin()
399 {
400     Buffer buffer2;
401 }
402