]>
Commit | Line | Data |
---|---|---|
b4c522fa IB |
1 | // PERMUTE_ARGS: |
2 | // EXTRA_SOURCES: imports/mangle10077.d | |
7da827c9 IB |
3 | // EXTRA_FILES: imports/testmangle.d |
4 | /* | |
5 | TEST_OUTPUT: | |
6 | --- | |
7 | _D7imports10testmangle12detectMangleFPSQBlQBg6DetectZQq | |
8 | _D7imports10testmangle__T10DetectTmplTiZQpFNaNbNiNfZv | |
9 | true | |
10 | false | |
11 | --- | |
12 | */ | |
b4c522fa | 13 | |
1af3f4a2 IB |
14 | import imports.testmangle; |
15 | ||
b4c522fa IB |
16 | /***************************************************/ |
17 | // 10077 - pragma(mangle) | |
18 | ||
19 | pragma(mangle, "_test10077a_") int test10077a; | |
20 | static assert(test10077a.mangleof == "_test10077a_"); | |
21 | ||
22 | __gshared pragma(mangle, "_test10077b_") ubyte test10077b; | |
23 | static assert(test10077b.mangleof == "_test10077b_"); | |
24 | ||
25 | pragma(mangle, "_test10077c_") void test10077c() {} | |
26 | static assert(test10077c.mangleof == "_test10077c_"); | |
27 | ||
28 | pragma(mangle, "_test10077f_") __gshared char test10077f; | |
29 | static assert(test10077f.mangleof == "_test10077f_"); | |
30 | ||
31 | pragma(mangle, "_test10077g_") @system { void test10077g() {} } | |
32 | static assert(test10077g.mangleof == "_test10077g_"); | |
33 | ||
34 | template getModuleInfo(alias mod) | |
35 | { | |
36 | pragma(mangle, "_D"~mod.mangleof~"12__ModuleInfoZ") static __gshared extern ModuleInfo mi; | |
37 | enum getModuleInfo = &mi; | |
38 | } | |
39 | ||
40 | void test10077h() | |
41 | { | |
42 | assert(getModuleInfo!(object).name == "object"); | |
43 | } | |
44 | ||
45 | //UTF-8 chars | |
46 | __gshared extern pragma(mangle, "test_эльфийские_письмена_9") ubyte test10077i_evar; | |
47 | ||
48 | void test10077i() | |
49 | { | |
50 | import imports.mangle10077; | |
51 | ||
52 | setTest10077i(); | |
53 | assert(test10077i_evar == 42); | |
54 | } | |
55 | ||
56 | /***************************************************/ | |
57 | // 13050 | |
58 | ||
59 | void func13050(int); | |
60 | template decl13050(Arg) | |
61 | { | |
62 | void decl13050(Arg); | |
63 | } | |
64 | template problem13050(Arg) | |
65 | { | |
66 | pragma(mangle, "foobar") | |
67 | void problem13050(Arg); | |
68 | } | |
69 | template workaround13050(Arg) | |
70 | { | |
71 | pragma(mangle, "foobar") | |
72 | void func(Arg); | |
73 | alias workaround13050 = func; | |
74 | } | |
75 | ||
76 | static assert(is(typeof(&func13050) == void function(int))); | |
77 | static assert(is(typeof(&decl13050!int) == void function(int))); | |
78 | static assert(is(typeof(&problem13050!int) == void function(int))); | |
79 | static assert(is(typeof(&workaround13050!int) == void function(int))); | |
80 | ||
81 | /***************************************************/ | |
82 | // 2774 | |
83 | ||
84 | int foo2774(int n) { return 0; } | |
85 | static assert(foo2774.mangleof == "_D6mangle7foo2774FiZi"); | |
86 | ||
87 | class C2774 | |
88 | { | |
89 | int foo2774() { return 0; } | |
90 | } | |
91 | static assert(C2774.foo2774.mangleof == "_D6mangle5C27747foo2774MFZi"); | |
92 | ||
93 | template TFoo2774(T) {} | |
1af3f4a2 | 94 | static assert(TFoo2774!int.mangleof == "6mangle"~tl!"15"~"__T8TFoo2774TiZ"); |
b4c522fa IB |
95 | |
96 | void test2774() | |
97 | { | |
98 | int foo2774(int n) { return 0; } | |
99 | static assert(foo2774.mangleof == "_D6mangle8test2774FZ7foo2774MFNaNbNiNfiZi"); | |
100 | } | |
101 | ||
102 | /*******************************************/ | |
103 | // 8847 | |
104 | ||
105 | auto S8847() | |
106 | { | |
107 | static struct Result | |
108 | { | |
109 | inout(Result) get() inout { return this; } | |
110 | } | |
111 | return Result(); | |
112 | } | |
113 | ||
114 | void test8847a() | |
115 | { | |
116 | auto a = S8847(); | |
117 | auto b = a.get(); | |
118 | alias typeof(a) A; | |
119 | alias typeof(b) B; | |
120 | assert(is(A == B), A.stringof~ " is different from "~B.stringof); | |
121 | } | |
122 | ||
123 | // -------- | |
124 | ||
125 | enum result8847a = "S6mangle9iota8847aFZ6Result"; | |
126 | enum result8847b = "S6mangle9iota8847bFZ4iotaMFZ6Result"; | |
127 | enum result8847c = "C6mangle9iota8847cFZ6Result"; | |
128 | enum result8847d = "C6mangle9iota8847dFZ4iotaMFZ6Result"; | |
129 | ||
130 | auto iota8847a() | |
131 | { | |
132 | static struct Result | |
133 | { | |
134 | this(int) {} | |
135 | inout(Result) test() inout { return cast(inout)Result(0); } | |
136 | } | |
137 | static assert(Result.mangleof == result8847a); | |
138 | return Result.init; | |
139 | } | |
140 | auto iota8847b() | |
141 | { | |
142 | auto iota() | |
143 | { | |
144 | static struct Result | |
145 | { | |
146 | this(int) {} | |
147 | inout(Result) test() inout { return cast(inout)Result(0); } | |
148 | } | |
149 | static assert(Result.mangleof == result8847b); | |
150 | return Result.init; | |
151 | } | |
152 | return iota(); | |
153 | } | |
154 | auto iota8847c() | |
155 | { | |
156 | static class Result | |
157 | { | |
158 | this(int) {} | |
159 | inout(Result) test() inout { return cast(inout)new Result(0); } | |
160 | } | |
161 | static assert(Result.mangleof == result8847c); | |
162 | return Result.init; | |
163 | } | |
164 | auto iota8847d() | |
165 | { | |
166 | auto iota() | |
167 | { | |
168 | static class Result | |
169 | { | |
170 | this(int) {} | |
171 | inout(Result) test() inout { return cast(inout)new Result(0); } | |
172 | } | |
173 | static assert(Result.mangleof == result8847d); | |
174 | return Result.init; | |
175 | } | |
176 | return iota(); | |
177 | } | |
178 | void test8847b() | |
179 | { | |
180 | static assert(typeof(iota8847a().test()).mangleof == result8847a); | |
181 | static assert(typeof(iota8847b().test()).mangleof == result8847b); | |
182 | static assert(typeof(iota8847c().test()).mangleof == result8847c); | |
183 | static assert(typeof(iota8847d().test()).mangleof == result8847d); | |
184 | } | |
185 | ||
186 | // -------- | |
187 | ||
188 | struct Test8847 | |
189 | { | |
1af3f4a2 IB |
190 | enum result1 = "S6mangle8Test8847"~tl!("8")~"__T3fooZ"~id!("3foo","Qf")~"MFZ6Result"; |
191 | enum result2 = "S6mangle8Test8847"~tl!("8")~"__T3fooZ"~id!("3foo","Qf")~"MxFiZ6Result"; | |
b4c522fa IB |
192 | |
193 | auto foo()() | |
194 | { | |
195 | static struct Result | |
196 | { | |
197 | inout(Result) get() inout { return this; } | |
198 | } | |
199 | static assert(Result.mangleof == Test8847.result1); | |
200 | return Result(); | |
201 | } | |
202 | auto foo()(int n) const | |
203 | { | |
204 | static struct Result | |
205 | { | |
206 | inout(Result) get() inout { return this; } | |
207 | } | |
208 | static assert(Result.mangleof == Test8847.result2); | |
209 | return Result(); | |
210 | } | |
211 | } | |
212 | void test8847c() | |
213 | { | |
214 | static assert(typeof(Test8847().foo( ).get()).mangleof == Test8847.result1); | |
215 | static assert(typeof(Test8847().foo(1).get()).mangleof == Test8847.result2); | |
216 | } | |
217 | ||
218 | // -------- | |
219 | ||
220 | void test8847d() | |
221 | { | |
222 | enum resultS = "S6mangle9test8847dFZ3fooMFZ3barMFZ3bazMFZ1S"; | |
223 | enum resultX = "S6mangle9test8847dFZ3fooMFZ1X"; | |
224 | // Return types for test8847d and bar are mangled correctly, | |
225 | // and return types for foo and baz are not mangled correctly. | |
226 | ||
227 | auto foo() | |
228 | { | |
229 | struct X { inout(X) get() inout { return inout(X)(); } } | |
230 | string bar() | |
231 | { | |
232 | auto baz() | |
233 | { | |
234 | struct S { inout(S) get() inout { return inout(S)(); } } | |
235 | return S(); | |
236 | } | |
237 | static assert(typeof(baz() ).mangleof == resultS); | |
238 | static assert(typeof(baz().get()).mangleof == resultS); | |
239 | return ""; | |
240 | } | |
241 | return X(); | |
242 | } | |
243 | static assert(typeof(foo() ).mangleof == resultX); | |
244 | static assert(typeof(foo().get()).mangleof == resultX); | |
245 | } | |
246 | ||
247 | // -------- | |
248 | ||
249 | void test8847e() | |
250 | { | |
1af3f4a2 | 251 | enum resultHere = "6mangle"~"9test8847eFZ"~tl!"8"~"__T3fooZ"~id!("3foo","Qf"); |
b4c522fa | 252 | enum resultBar = "S"~resultHere~"MFNaNfNgiZ3Bar"; |
1af3f4a2 IB |
253 | static if(BackRefs) {} else |
254 | enum resultFoo = "_D"~resultHere~"MFNaNbNiNfNgiZNg"~resultBar; // added 'Nb' | |
b4c522fa IB |
255 | |
256 | // Make template function to infer 'nothrow' attributes | |
257 | auto foo()(inout int) pure @safe | |
258 | { | |
259 | struct Bar {} | |
260 | static assert(Bar.mangleof == resultBar); | |
261 | return inout(Bar)(); | |
262 | } | |
263 | ||
1af3f4a2 | 264 | import core.demangle : demangle, demangleType; |
b4c522fa IB |
265 | auto bar = foo(0); |
266 | static assert(typeof(bar).stringof == "Bar"); | |
267 | static assert(typeof(bar).mangleof == resultBar); | |
1af3f4a2 IB |
268 | enum fooDemangled = "pure nothrow @nogc @safe inout(mangle.test8847e().foo!().foo(inout(int)).Bar) mangle.test8847e().foo!().foo(inout(int))"; |
269 | ||
270 | static if (BackRefs) | |
271 | static assert(demangle(foo!().mangleof) == fooDemangled); | |
272 | else | |
273 | static assert(foo!().mangleof == resultFoo); | |
b4c522fa IB |
274 | } |
275 | ||
276 | // -------- | |
277 | ||
278 | pure f8847a() | |
279 | { | |
280 | struct S {} | |
281 | return S(); | |
282 | } | |
283 | ||
284 | pure | |
285 | { | |
286 | auto f8847b() | |
287 | { | |
288 | struct S {} | |
289 | return S(); | |
290 | } | |
291 | } | |
292 | ||
293 | static assert(typeof(f8847a()).mangleof == "S6mangle6f8847aFNaZ1S"); | |
294 | static assert(typeof(f8847b()).mangleof == "S6mangle6f8847bFNaZ1S"); | |
295 | ||
296 | /*******************************************/ | |
297 | // 12352 | |
298 | ||
299 | auto bar12352() | |
300 | { | |
301 | struct S { int var; void func() {} } | |
302 | ||
303 | static assert(!__traits(compiles, bar12352.mangleof)); // forward reference to bar | |
304 | static assert(S .mangleof == "S6mangle8bar12352FZ1S"); | |
305 | static assert(S.func.mangleof == "_D6mangle8bar12352FZ1S4funcMFZv"); | |
306 | ||
307 | return S(); | |
308 | } | |
1af3f4a2 | 309 | static assert( bar12352 .mangleof == "_D6mangle8bar12352FNaNbNiNfZS"~id!("6mangle8bar12352FZ","QBbQxFZ","QL2H")~"1S"); |
b4c522fa IB |
310 | static assert(typeof(bar12352()) .mangleof == "S6mangle8bar12352FZ1S"); |
311 | static assert(typeof(bar12352()).func.mangleof == "_D6mangle8bar12352FZ1S4funcMFZv"); | |
312 | ||
313 | auto baz12352() | |
314 | { | |
315 | class C { int var; void func() {} } | |
316 | ||
317 | static assert(!__traits(compiles, baz12352.mangleof)); // forward reference to baz | |
318 | static assert(C .mangleof == "C6mangle8baz12352FZ1C"); | |
319 | static assert(C.func.mangleof == "_D6mangle8baz12352FZ1C4funcMFZv"); | |
320 | ||
321 | return new C(); | |
322 | } | |
1af3f4a2 | 323 | static assert( baz12352 .mangleof == "_D6mangle8baz12352FNaNbNfZC"~id!("6mangle8baz12352FZ","QzQuFZ","QL2F")~"1C"); |
b4c522fa IB |
324 | static assert(typeof(baz12352()) .mangleof == "C6mangle8baz12352FZ1C"); |
325 | static assert(typeof(baz12352()).func.mangleof == "_D6mangle8baz12352FZ1C4funcMFZv"); | |
326 | ||
327 | /*******************************************/ | |
328 | // 9525 | |
329 | ||
330 | void f9525(T)(in T*) { } | |
331 | ||
332 | void test9525() | |
333 | { | |
1af3f4a2 IB |
334 | enum result1 = "S6mangle8test9525FZ"~tl!"26"~"__T5test1S"~tl!"13"~id!("6mangle","QBc")~"5f9525Z"~id!("5test1","Qr")~"MFZ1S"; |
335 | enum result2 = "S6mangle8test9525FZ"~tl!"26"~"__T5test2S"~tl!"13"~id!("6mangle","QBc")~"5f9525Z"~id!("5test2","Qr")~"MFNaNbZ1S"; | |
b4c522fa IB |
336 | |
337 | void test1(alias a)() | |
338 | { | |
339 | static struct S {} | |
340 | static assert(S.mangleof == result1); | |
341 | S s; | |
342 | a(&s); // Error: Cannot convert &S to const(S*) at compile time | |
343 | } | |
344 | static assert((test1!f9525(), true)); | |
345 | ||
346 | void test2(alias a)() pure nothrow | |
347 | { | |
348 | static struct S {} | |
349 | static assert(S.mangleof == result2); | |
350 | S s; | |
351 | a(&s); // Error: Cannot convert &S to const(S*) at compile time | |
352 | } | |
353 | static assert((test2!f9525(), true)); | |
354 | } | |
355 | ||
356 | /******************************************/ | |
357 | // 10249 | |
358 | ||
359 | template Seq10249(T...) { alias Seq10249 = T; } | |
360 | ||
361 | mixin template Func10249(T) | |
362 | { | |
363 | void func10249(T) {} | |
364 | } | |
365 | mixin Func10249!long; | |
366 | mixin Func10249!string; | |
367 | ||
368 | void f10249(long) {} | |
369 | ||
370 | class C10249 | |
371 | { | |
372 | mixin Func10249!long; | |
373 | mixin Func10249!string; | |
374 | static assert(Seq10249!(.func10249)[0].mangleof == "6mangle9func10249"); // <- 9func10249 | |
375 | static assert(Seq10249!( func10249)[0].mangleof == "6mangle6C102499func10249"); // <- 9func10249 | |
376 | ||
377 | static: // necessary to make overloaded symbols accessible via __traits(getOverloads, C10249) | |
378 | void foo(long) {} | |
379 | void foo(string) {} | |
380 | static assert(Seq10249!(foo)[0].mangleof == "6mangle6C102493foo"); // <- _D6mangle6C102493fooFlZv | |
381 | static assert(Seq10249!(__traits(getOverloads, C10249, "foo"))[0].mangleof == "_D6mangle6C102493fooFlZv"); // <- | |
382 | static assert(Seq10249!(__traits(getOverloads, C10249, "foo"))[1].mangleof == "_D6mangle6C102493fooFAyaZv"); // <- | |
383 | ||
384 | void g(string) {} | |
385 | alias bar = .f10249; | |
386 | alias bar = g; | |
387 | static assert(Seq10249!(bar)[0].mangleof == "6mangle6C102493bar"); // <- _D6mangle1fFlZv | |
388 | static assert(Seq10249!(__traits(getOverloads, C10249, "bar"))[0].mangleof == "_D6mangle6f10249FlZv"); // <- | |
389 | static assert(Seq10249!(__traits(getOverloads, C10249, "bar"))[1].mangleof == "_D6mangle6C102491gFAyaZv"); // <- | |
390 | } | |
391 | ||
392 | /*******************************************/ | |
393 | // 11718 | |
394 | ||
395 | struct Ty11718(alias sym) {} | |
396 | ||
397 | auto fn11718(T)(T a) { return Ty11718!(a).mangleof; } | |
398 | auto fn11718(T)() { T a; return Ty11718!(a).mangleof; } | |
399 | ||
400 | void test11718() | |
401 | { | |
402 | string TyName(string tail)() | |
403 | { | |
404 | enum s = "__T7Ty11718" ~ tail; | |
1af3f4a2 IB |
405 | enum len = unsignedToString(s.length); |
406 | return "S6mangle" ~ tl!(len) ~ s; | |
b4c522fa IB |
407 | } |
408 | string fnName(string paramPart)() | |
409 | { | |
1af3f4a2 | 410 | enum s = "_D6mangle"~tl!("35")~"__T7fn11718T"~ |
b4c522fa IB |
411 | "S6mangle9test11718FZ1AZ7fn11718"~paramPart~"1a"~ |
412 | "S6mangle9test11718FZ1A"; | |
1af3f4a2 IB |
413 | enum len = unsignedToString(s.length); |
414 | return tl!len ~ s; | |
b4c522fa IB |
415 | } |
416 | enum result1 = TyName!("S" ~ fnName!("F"~"S6mangle9test11718FZ1A"~"Z") ~ "Z") ~ "7Ty11718"; | |
417 | enum result2 = TyName!("S" ~ fnName!("F"~"" ~"Z") ~ "Z") ~ "7Ty11718"; | |
418 | ||
419 | struct A {} | |
1af3f4a2 IB |
420 | static if (BackRefs) |
421 | { | |
422 | static assert(fn11718(A.init) == "S6mangle__T7Ty11718S_DQv__T7fn11718TSQBk9test11718FZ1AZQBcFQxZ1aQBcZQCf"); | |
423 | static assert(fn11718!A() == "S6mangle__T7Ty11718S_DQv__T7fn11718TSQBk9test11718FZ1AZQBcFZ1aQBaZQCd"); | |
424 | } | |
425 | else | |
426 | { | |
427 | pragma(msg, fn11718(A.init)); | |
428 | static assert(fn11718(A.init) == result1); | |
429 | static assert(fn11718!A() == result2); | |
430 | } | |
b4c522fa IB |
431 | } |
432 | ||
433 | /*******************************************/ | |
434 | // 11776 | |
435 | ||
436 | struct S11776(alias fun) { } | |
437 | ||
438 | void test11776() | |
439 | { | |
440 | auto g = () | |
441 | { | |
442 | if (1) | |
443 | return; // fill tf->next | |
444 | if (1) | |
445 | { | |
446 | auto s = S11776!(a => 1)(); | |
447 | static assert(typeof(s).mangleof == | |
1af3f4a2 IB |
448 | "S"~"6mangle"~tl!("56")~ |
449 | ("__T"~"6S11776"~"S"~tl!("42")~ | |
450 | (id!("6mangle","Qs")~"9test11776"~"FZ"~"9__lambda1MFZ"~id!("9__lambda1","Qn"))~"Z" | |
451 | )~id!("6S11776", "QBm")); | |
b4c522fa IB |
452 | } |
453 | }; | |
454 | } | |
455 | ||
456 | /***************************************************/ | |
457 | // 12044 | |
458 | ||
459 | struct S12044(T) | |
460 | { | |
461 | void f()() | |
462 | { | |
463 | new T[1]; | |
464 | } | |
465 | ||
466 | bool opEquals(O)(O) | |
467 | { | |
468 | f(); | |
469 | } | |
470 | } | |
471 | ||
472 | void test12044() | |
473 | { | |
474 | () | |
475 | { | |
476 | enum E { e } | |
477 | auto arr = [E.e]; | |
478 | S12044!E s; | |
479 | } | |
480 | (); | |
481 | } | |
482 | ||
483 | /*******************************************/ | |
484 | // 12217 | |
485 | ||
486 | void test12217(int) | |
487 | { | |
488 | static struct S {} | |
489 | void bar() {} | |
490 | int var; | |
491 | template X(T) {} | |
492 | ||
493 | static assert( S.mangleof == "S6mangle9test12217FiZ1S"); | |
494 | static assert( bar.mangleof == "_D6mangle9test12217FiZ3barMFNaNbNiNfZv"); | |
495 | static assert( var.mangleof == "_D6mangle9test12217FiZ3vari"); | |
1af3f4a2 | 496 | static assert(X!int.mangleof == "6mangle9test12217FiZ"~tl!("8")~"__T1XTiZ"); |
b4c522fa IB |
497 | } |
498 | ||
499 | void test12217() {} | |
500 | ||
501 | /***************************************************/ | |
502 | // 12231 | |
503 | ||
504 | void func12231a()() | |
505 | if (is(typeof({ | |
506 | class C {} | |
507 | static assert(C.mangleof == | |
1af3f4a2 | 508 | "C6mangle"~tl!("16")~"__U10func12231aZ"~id!("10func12231a","Qn")~"FZ9__lambda1MFZ1C"); |
b4c522fa IB |
509 | // ### L # |
510 | }))) | |
511 | {} | |
512 | ||
513 | void func12231b()() | |
514 | if (is(typeof({ | |
1af3f4a2 IB |
515 | class C {} static assert(C.mangleof == |
516 | "C6mangle"~tl!("16")~"__U10func12231bZ"~id!("10func12231b","Qn")~"FZ9__lambda1MFZ1C"); | |
b4c522fa | 517 | // L__L L LL |
1af3f4a2 | 518 | })) && |
b4c522fa IB |
519 | is(typeof({ |
520 | class C {} | |
521 | static assert(C.mangleof == | |
1af3f4a2 | 522 | "C6mangle"~tl!("16")~"__U10func12231bZ"~id!("10func12231b","Qn")~"FZ9__lambda2MFZ1C"); |
b4c522fa IB |
523 | // L__L L LL |
524 | }))) | |
525 | {} | |
526 | ||
527 | void func12231c()() | |
528 | if (is(typeof({ | |
529 | class C {} | |
530 | static assert(C.mangleof == | |
1af3f4a2 | 531 | "C6mangle"~tl!("16")~"__U10func12231cZ"~id!("10func12231c","Qn")~"FZ9__lambda1MFZ1C"); |
b4c522fa IB |
532 | // L__L L LL |
533 | }))) | |
534 | { | |
535 | (){ | |
536 | class C {} | |
537 | static assert(C.mangleof == | |
1af3f4a2 | 538 | "C6mangle"~tl!("16")~"__T10func12231cZ"~id!("10func12231c","Qn")~"FZ9__lambda1MFZ1C"); |
b4c522fa IB |
539 | // L__L L LL |
540 | }(); | |
541 | } | |
542 | ||
543 | void func12231c(X)() | |
544 | if (is(typeof({ | |
545 | class C {} | |
1af3f4a2 IB |
546 | static assert(C.mangleof == |
547 | "C6mangle"~tl!("20")~"__U10func12231cTAyaZ"~id!("10func12231c","Qr")~"FZ9__lambda1MFZ1C"); | |
b4c522fa IB |
548 | // L__L L___L LL |
549 | }))) | |
550 | { | |
551 | (){ | |
552 | class C {} | |
553 | static assert(C.mangleof == | |
1af3f4a2 | 554 | "C6mangle"~tl!("20")~"__T10func12231cTAyaZ"~id!("10func12231c","Qr")~"FZ9__lambda1MFZ1C"); |
b4c522fa IB |
555 | // L__L L___L LL |
556 | }(); | |
557 | } | |
558 | ||
559 | void test12231() | |
560 | { | |
561 | func12231a(); | |
562 | ||
563 | func12231b(); | |
564 | ||
565 | func12231c(); | |
566 | func12231c!string(); | |
567 | } | |
568 | ||
569 | /***************************************************/ | |
570 | ||
571 | int test2a(scope int a) { return a; } | |
572 | ||
573 | static assert(test2a.mangleof == "_D6mangle6test2aFiZi"); | |
574 | ||
575 | /***************************************************/ | |
576 | ||
577 | class CC | |
578 | { | |
579 | int* p; | |
580 | ||
581 | int* member() scope | |
582 | { | |
583 | return p; | |
584 | } | |
585 | } | |
586 | ||
587 | static assert(CC.member.mangleof == "_D6mangle2CC6memberMFNlZPi"); | |
588 | ||
589 | /***************************************************/ | |
590 | ||
591 | void fooA(void delegate (scope void delegate()) dg) | |
592 | { | |
593 | } | |
594 | void fooB(void delegate (void delegate()) scope dg) | |
595 | { | |
596 | } | |
597 | ||
598 | //pragma(msg, fooA.mangleof); | |
599 | //pragma(msg, fooB.mangleof); | |
600 | static assert(typeof(fooA).mangleof != typeof(fooB).mangleof); | |
601 | ||
602 | ||
603 | /***************************************************/ | |
604 | ||
605 | void main() | |
606 | { | |
607 | test10077h(); | |
608 | test10077i(); | |
609 | test12044(); | |
610 | } |