1 // PERMUTE_ARGS:
2
3 module breaker;
4
5 import core.stdc.stdio, core.vararg;
6
7 /**********************************/
8
foo(T,U)9 U foo(T, U)(U i)
10 {
11 return i + 1;
12 }
13
foo(T)14 int foo(T)(int i)
15 {
16 return i + 2;
17 }
18
test1()19 void test1()
20 {
21 auto i = foo!(int)(2L);
22 // assert(i == 4); // now returns 3
23 }
24
25 /**********************************/
26
foo2(T,U)27 U foo2(T, U)(U i)
28 {
29 return i + 1;
30 }
31
test2()32 void test2()
33 {
34 auto i = foo2!(int)(2L);
35 assert(i == 3);
36 }
37
38 /**********************************/
39
40 class Foo3
41 {
bar(T,U)42 T bar(T,U)(U u)
43 {
44 return cast(T)u;
45 }
46 }
47
test3()48 void test3()
49 {
50 Foo3 foo = new Foo3;
51 int i = foo.bar!(int)(1.0);
52 assert(i == 1);
53 }
54
55
56 /**********************************/
57
begin4(T)58 T* begin4(T)(T[] a) { return a.ptr; }
59
60 void copy4(string pred = "", Ranges...)(Ranges rs)
61 {
62 alias rs[$ - 1] target;
63 pragma(msg, typeof(target).stringof);
64 auto tb = begin4(target);//, te = end(target);
65 }
66
test4()67 void test4()
68 {
69 int[] a, b, c;
70 copy4(a, b, c);
71 // comment the following line to prevent compiler from crashing
72 copy4!("a > 1")(a, b, c);
73 }
74
75 /**********************************/
76
77 import std.stdio:writefln;
78
foo5(T,S)79 template foo5(T,S)
80 {
81 void foo5(T t, S s) {
82 writefln("typeof(T)=",typeid(T)," typeof(S)=",typeid(S));
83 }
84 }
85
bar5(T,S)86 template bar5(T,S)
87 {
88 void bar5(S s) {
89 writefln("typeof(T)=",typeid(T),"typeof(S)=",typeid(S));
90 }
91 }
92
93
test5()94 void test5()
95 {
96 foo5(1.0,33);
97 bar5!(double,int)(33);
98 bar5!(float)(33);
99 }
100
101 /**********************************/
102
foo6(T...)103 int foo6(T...)(auto ref T x)
104 { int result;
105
106 foreach (i, v; x)
107 {
108 if (v == 10)
109 assert(__traits(isRef, x[i]));
110 else
111 assert(!__traits(isRef, x[i]));
112 result += v;
113 }
114 return result;
115 }
116
test6()117 void test6()
118 { int y = 10;
119 int r;
120 r = foo6(8);
121 assert(r == 8);
122 r = foo6(y);
123 assert(r == 10);
124 r = foo6(3, 4, y);
125 assert(r == 17);
126 r = foo6(4, 5, y);
127 assert(r == 19);
128 r = foo6(y, 6, y);
129 assert(r == 26);
130 }
131
132 /**********************************/
133
min(T,U)134 auto ref min(T, U)(auto ref T lhs, auto ref U rhs)
135 {
136 return lhs > rhs ? rhs : lhs;
137 }
138
test7()139 void test7()
140 { int x = 7, y = 8;
141 int i;
142
143 i = min(4, 3);
144 assert(i == 3);
145 i = min(x, y);
146 assert(i == 7);
147 min(x, y) = 10;
148 assert(x == 10);
149 static assert(!__traits(compiles, min(3, y) = 10));
150 static assert(!__traits(compiles, min(y, 3) = 10));
151 }
152
153 /**********************************/
154 // 5946
155
TTest8()156 template TTest8()
157 {
158 int call(){ return this.g(); }
159 }
160 class CTest8
161 {
f()162 int f() { mixin TTest8!(); return call(); }
g()163 int g() { return 10; }
164 }
test8()165 void test8()
166 {
167 assert((new CTest8()).f() == 10);
168 }
169
170 /**********************************/
171 // 693
172
TTest9(alias sym)173 template TTest9(alias sym)
174 {
175 int call(){ return sym.g(); }
176 }
177 class CTest9
178 {
f1()179 int f1() { mixin TTest9!(this); return call(); }
f2()180 int f2() { mixin TTest9!this; return call(); }
g()181 int g() { return 10; }
182 }
test9()183 void test9()
184 {
185 assert((new CTest9()).f1() == 10);
186 assert((new CTest9()).f2() == 10);
187 }
188
189 /**********************************/
190 // 1780
191
Tuple1780(Ts...)192 template Tuple1780(Ts ...) { alias Ts Tuple1780; }
193
Decode1780(T)194 template Decode1780( T ) { alias Tuple1780!() Types; }
195 template Decode1780( T : TT!(Us), alias TT, Us... ) { alias Us Types; }
196
test1780()197 void test1780()
198 {
199 struct S1780(T1, T2) {}
200
201 // should extract tuple (bool,short) but matches the first specialisation
202 alias Decode1780!( S1780!(bool,short) ).Types SQ1780; // --> SQ2 is empty tuple!
203 static assert(is(SQ1780 == Tuple1780!(bool, short)));
204 }
205
206 /**********************************/
207 // 1659
208
209 class Foo1659 { }
210 class Bar1659 : Foo1659 { }
211
212 void f1659(T : Foo1659)() { }
f1659(alias T)213 void f1659(alias T)() { static assert(false); }
214
test1659()215 void test1659()
216 {
217 f1659!Bar1659();
218 }
219
220 /**********************************/
221 // 2025
222
223 struct S2025 {}
f2025()224 void f2025() {}
225
Foo2025(int i)226 template Foo2025(int i) { enum Foo2025 = 1; }
Foo2025(TL...)227 template Foo2025(TL...) { enum Foo2025 = 2; }
228 static assert(Foo2025!1 == 1);
229 static assert(Foo2025!int == 2);
230 static assert(Foo2025!S2025 == 2);
231 static assert(Foo2025!f2025 == 2);
232
Bar2025(T)233 template Bar2025(T) { enum Bar2025 = 1; }
Bar2025(A...)234 template Bar2025(A...) { enum Bar2025 = 2; }
235 static assert(Bar2025!1 == 2);
236 static assert(Bar2025!int == 1); // 2 -> 1
237 static assert(Bar2025!S2025 == 1); // 2 -> 1
238 static assert(Bar2025!f2025 == 2);
239
Baz2025(T)240 template Baz2025(T) { enum Baz2025 = 1; }
Baz2025(alias A)241 template Baz2025(alias A) { enum Baz2025 = 2; }
242 static assert(Baz2025!1 == 2);
243 static assert(Baz2025!int == 1);
244 static assert(Baz2025!S2025 == 1); // 2 -> 1
245 static assert(Baz2025!f2025 == 2);
246
247 /**********************************/
248 // 3608
249
foo3608(T,U)250 template foo3608(T, U){}
251
252 template BaseTemplate3608(alias TTT : U!V, alias U, V...)
253 {
254 alias U BaseTemplate3608;
255 }
256 template TemplateParams3608(alias T : U!V, alias U, V...)
257 {
258 alias V TemplateParams3608;
259 }
260
TyueTuple3608(T...)261 template TyueTuple3608(T...) { alias T TyueTuple3608; }
262
test3608()263 void test3608()
264 {
265 alias foo3608!(int, long) Foo3608;
266
267 static assert(__traits(isSame, BaseTemplate3608!Foo3608, foo3608));
268 static assert(is(TemplateParams3608!Foo3608 == TyueTuple3608!(int, long)));
269 }
270
271 /**********************************/
272 // 5015
273
274 import breaker;
275
276 static if (is(ElemType!(int))){}
277
ElemType(T)278 template ElemType(T) {
279 alias _ElemType!(T).type ElemType;
280 }
281
_ElemType(T)282 template _ElemType(T) {
283 alias r type;
284 }
285
286 /**********************************/
287 // 5185
288
C5185(V)289 class C5185(V)
290 {
291 void f()
292 {
293 C5185!(C5185!(int)) c;
294 }
295 }
296
test5185()297 void test5185()
298 {
299 C5185!(C5185!(int)) c;
300 }
301
302 /**********************************/
303 // 5893
304
305 class C5893
306 {
concatAssign(C5893 other)307 int concatAssign(C5893 other) { return 1; }
concatAssign(int other)308 int concatAssign(int other) { return 2; } // to demonstrate overloading
309
310 template opOpAssign(string op) if (op == "~")
311 { alias concatAssign opOpAssign; }
312
313 int opOpAssign(string op)(int other) if (op == "+") { return 3; }
314 }
315
test5893()316 void test5893()
317 {
318 auto c = new C5893;
319 assert(c.opOpAssign!"~"(c) == 1); // works
320 assert(c.opOpAssign!"~"(1) == 2); // works
321 assert((c ~= 1) == 2);
322 assert((c += 1) == 3); // overload
323 }
324
325 /**********************************/
326 // 5988
327
Templ5988(alias T)328 template Templ5988(alias T)
329 {
330 alias T!int Templ5988;
331 }
332
C5988a(T)333 class C5988a(T) { Templ5988!C5988a foo; }
334 //Templ5988!C5988a foo5988a; // Commented version
test5988a()335 void test5988a() { C5988a!int a; } // Was error, now works
336
C5988b(T)337 class C5988b(T) { Templ5988!C5988b foo; }
338 Templ5988!C5988b foo5988b; // Uncomment version
test5988b()339 void test5988b() { C5988b!int a; } // Works
340
341 /**********************************/
342 // 6404
343
344 // receive only rvalue
345 void rvalue(T)(auto ref T x) if (!__traits(isRef, x)) {}
346 void rvalueVargs(T...)(auto ref T x) if (!__traits(isRef, x[0])) {}
347
348 // receive only lvalue
349 void lvalue(T)(auto ref T x) if ( __traits(isRef, x)) {}
350 void lvalueVargs(T...)(auto ref T x) if ( __traits(isRef, x[0])) {}
351
test6404()352 void test6404()
353 {
354 int n;
355
356 static assert(!__traits(compiles, rvalue(n)));
357 static assert( __traits(compiles, rvalue(0)));
358
359 static assert( __traits(compiles, lvalue(n)));
360 static assert(!__traits(compiles, lvalue(0)));
361
362 static assert(!__traits(compiles, rvalueVargs(n)));
363 static assert( __traits(compiles, rvalueVargs(0)));
364
365 static assert( __traits(compiles, lvalueVargs(n)));
366 static assert(!__traits(compiles, lvalueVargs(0)));
367 }
368
369 /**********************************/
370 // 2246
371
A2246(T,d)372 class A2246(T,d){
373 T p;
374 }
375
B2246(int rk)376 class B2246(int rk){
377 int[rk] p;
378 }
379
C2246(T,int rk)380 class C2246(T,int rk){
381 T[rk] p;
382 }
383
384 template f2246(T:A2246!(U,d),U,d){
f2246()385 void f2246(){ }
386 }
387
388 template f2246(T:B2246!(rank),int rank){
f2246()389 void f2246(){ }
390 }
391
392 template f2246(T:C2246!(U,rank),U,int rank){
f2246()393 void f2246(){ }
394 }
395
test2246()396 void test2246(){
397 A2246!(int,long) a;
398 B2246!(2) b;
399 C2246!(int,2) c;
400 f2246!(A2246!(int,long))();
401 f2246!(B2246!(2))();
402 f2246!(C2246!(int,2))();
403 }
404
405 /**********************************/
406 // 2296
407
foo2296(size_t D)408 void foo2296(size_t D)(int[D] i...){}
test2296()409 void test2296()
410 {
411 foo2296(1, 2, 3);
412 }
413
414 /**********************************/
415 // 1684
416
Test1684(uint memberOffset)417 template Test1684( uint memberOffset ){}
418
419 class MyClass1684 {
420 int flags2;
421 mixin Test1684!(cast(uint)flags2.offsetof) t1; // compiles ok
422 mixin Test1684!(cast(int)flags2.offsetof) t2; // compiles ok
423 mixin Test1684!(flags2.offsetof) t3; // Error: no property 'offsetof' for type 'int'
424 }
425
426 /**********************************/
427
428 void bug4984a(int n)() if (n > 0 && is(typeof(bug4984a!(n-1) ()))) {
429 }
430
431 void bug4984a(int n : 0)() {
432 }
433
434 void bug4984b(U...)(U args) if ( is(typeof( bug4984b(args[1..$]) )) ) {
435 }
436
bug4984b(U)437 void bug4984b(U)(U u) {
438 }
439
bug4984()440 void bug4984() {
441 // Note: compiling this overflows the stack if dmd is build with DEBUG
442 //bug4984a!400();
443 bug4984a!200();
444 bug4984b(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19);
445 }
446
447 /***************************************/
448 // 2579
449
foo2579(T)450 void foo2579(T)(T delegate(in Object) dlg)
451 {
452 }
453
test2579()454 void test2579()
455 {
456 foo2579( (in Object o) { return 15; } );
457 }
458
459 /**********************************/
460 // 2803
461
foo2803(T)462 auto foo2803(T)(T t = 0) { return t; }
463
464 struct S2803 {}
465 S2803 s2803;
getS2803()466 ref S2803 getS2803() { return s2803; }
fun2803(T,U)467 auto fun2803(T, U)(T t, ref U u = getS2803)
468 {
469 static assert(is(U == S2803));
470 return &u;
471 }
472
473 // from the past version of std.conv
to2803(T)474 template to2803(T) { T to2803(S)(S src) { return T.init; } }
toImpl2803a(T,S)475 auto toImpl2803a(T, S)(S s, in T left, in T sep = ", ", in T right = "]") {}
toImpl2803b(T,S)476 auto toImpl2803b(T, S)(S s, in T left = to2803!T(S.stringof~"("), in T right = ")") {}
toImpl2803c(T,S)477 auto toImpl2803c(T, S)(S s, in T left = S.stringof~"(" , in T right = ")") {} // combination with enh 13944
478
479 // from std.range.package in 2.067a.
480 auto enumerate2803(En = size_t, R)(R r, En start = 0)
481 {
482 // The type of 'start' should be size_t, it's the defaultArg of En,
483 // rather than the deduced type from its defualtArg '0'.
484 static assert(is(typeof(start) == size_t));
485 return start;
486 }
487
488 // from std.numeric.
489 alias ElementType2803(R) = typeof(R.init[0].init);
normalize2803(R)490 void normalize2803(R)(R range, ElementType2803!R sum = 1)
491 {
492 // The type of 'sum' should be determined to ElementType!(double[]) == double
493 // before the type deduction from its defaultArg '1'.
494 static assert(is(typeof(sum) == double));
495 }
496
foo14468(T)497 auto foo14468(T)(T[]...) { return 1; }
foo14468(bool flag,T)498 auto foo14468(bool flag, T)(T[]...) { return 2; }
499
test2803()500 void test2803()
501 {
502 assert(foo2803() == 0);
503 assert(foo2803(1) == 1);
504
505 S2803 s;
506 assert(fun2803(1) is &s2803);
507 assert(fun2803(1, s) is &s);
508
509 // regression cases
510
511 toImpl2803a!string(1, "[");
512
513 toImpl2803b! string(1);
514 toImpl2803b!wstring(1);
515 toImpl2803b!dstring(1);
516
517 toImpl2803c! string(1);
518 toImpl2803c!wstring(1); // requires enhancement 13944
519 toImpl2803c!dstring(1); // requires enhancement 13944
520
521 enumerate2803([1]);
522
523 double[] a = [];
524 normalize2803(a);
525
526 assert(foo14468!int() == 1);
527 }
528
529 /**********************************/
530 // 6613
531
532 alias Tuple6613(T...) = T;
533
f6613(T...)534 void f6613(T...)(int x = 0, T xs = Tuple6613!())
535 {
536 assert(x == 0);
537 static assert(T.length == 0);
538 }
539
test6613()540 void test6613()
541 {
542 f6613();
543 }
544
545 /**********************************/
546 // 4953
547
548 void bug4953(T = void)(short x) {}
549 static assert(is(typeof(bug4953(3))));
550
551 /**********************************/
552 // 5886 & 5393
553
Foo5886(T)554 mixin template Foo5886(T)
555 {
556 void foo(U : T, this X)() const { static assert(is(X == const K5886)); }
557 }
558
559 struct K5886
560 {
get1K5886561 void get1(this T)() const
562 {
563 pragma(msg, T);
564 }
565 void get2(int N=4, this T)() const
566 {
567 pragma(msg, N, " ; ", T);
568 }
569
570 mixin Foo5886!double;
571 mixin Foo5886!string;
572
testK5886573 void test() const
574 {
575 get1; // OK
576 get2; // OK
577 get2!8; // NG
578
579 foo!(int);
580 foo!(typeof(null));
581 }
582 }
583
test5886()584 void test5886()
585 {
586 K5886 km;
587 const(K5886) kc;
588 immutable(K5886) ki;
589
590 km.get1; // OK
591 kc.get1; // OK
592 ki.get1; // OK
593 km.get2; // OK
594 kc.get2; // OK
595 ki.get2; // OK
596 km.get2!(1, K5886); // Ugly
597 kc.get2!(2, const(K5886)); // Ugly
598 ki.get2!(3, immutable(K5886)); // Ugly
599 km.get2!8; // Error
600 kc.get2!9; // Error
601 ki.get2!10; // Error
602 }
603
604 // --------
605
test5393()606 void test5393()
607 {
608 class A
609 {
610 void opDispatch (string name, this T) () { }
611 }
612
613 class B : A {}
614
615 auto b = new B;
616 b.foobar();
617 }
618
619 /**********************************/
620 // 5896
621
622 struct X5896
623 {
opCastX5896624 T opCast(T)(){ return 1; }
opCastX5896625 const T opCast(T)(){ return 2; }
opCastX5896626 immutable T opCast(T)(){ return 3; }
opCastX5896627 shared T opCast(T)(){ return 4; }
opCastX5896628 const shared T opCast(T)(){ return 5; }
629 }
test5896()630 void test5896()
631 {
632 auto xm = X5896 ();
633 auto xc = const(X5896) ();
634 auto xi = immutable(X5896) ();
635 auto xs = shared(X5896) ();
636 auto xcs= const(shared(X5896))();
637 assert(cast(int)xm == 1);
638 assert(cast(int)xc == 2);
639 assert(cast(int)xi == 3);
640 assert(cast(int)xs == 4);
641 assert(cast(int)xcs== 5);
642 }
643
644 /**********************************/
645 // 6312
646
h6312()647 void h6312() {}
648
649 class Bla6312
650 {
651 mixin wrap6312!h6312;
652 }
653
wrap6312(alias f)654 mixin template wrap6312(alias f)
655 {
656 void blub(alias g = f)()
657 {
658 g();
659 }
660 }
661
test6312()662 void test6312()
663 {
664 Bla6312 b = new Bla6312();
665 b.blub();
666 }
667
668 /**********************************/
669 // 6825
670
test6825()671 void test6825()
672 {
673 struct File
674 {
675 void write(S...)(S args) {}
676 }
677
678 void dump(void delegate(string) d) {}
679
680 auto o = File();
681 dump(&o.write!string);
682 }
683
684 /**********************************/
685 // 6789
686
isStaticArray6789(T)687 template isStaticArray6789(T)
688 {
689 static if (is(T U : U[N], size_t N)) // doesn't match
690 {
691 pragma(msg, "> U = ", U, ", N:", typeof(N), " = ", N);
692 enum isStaticArray6789 = true;
693 }
694 else
695 enum isStaticArray6789 = false;
696 }
697
test6789()698 void test6789()
699 {
700 alias int[3] T;
701 static assert(isStaticArray6789!T);
702 }
703
704 /**********************************/
705 // 2778
706
ArrayWrapper2778(T)707 struct ArrayWrapper2778(T)
708 {
709 T[] data;
710 alias data this;
711 }
712
doStuffFunc2778(int[]data)713 void doStuffFunc2778(int[] data) {}
714
doStuffTempl2778(T)715 void doStuffTempl2778(T)(T[] data) {}
716
doStuffTemplOver2778(T)717 int doStuffTemplOver2778(T)(void* data) { return 1; }
doStuffTemplOver2778(T)718 int doStuffTemplOver2778(T)(ArrayWrapper2778!T w) { return 2; }
719
test2778()720 void test2778()
721 {
722 ArrayWrapper2778!(int) foo;
723
724 doStuffFunc2778(foo); // Works.
725
726 doStuffTempl2778!(int)(foo); // Works.
727
728 doStuffTempl2778(foo); // Error
729
730 assert(doStuffTemplOver2778(foo) == 2);
731 }
732
733 // ----
734
test2778aa()735 void test2778aa()
736 {
737 void foo(K, V)(V[K] aa){ pragma(msg, "K=", K, ", V=", V); }
738
739 int[string] aa1;
740 foo(aa1); // OK
741
742 struct SubTypeOf(T)
743 {
744 T val;
745 alias val this;
746 }
747 SubTypeOf!(string[char]) aa2;
748 foo(aa2); // NG
749 }
750
751 // ----
752
test2778get()753 void test2778get()
754 {
755 void foo(ubyte[]){}
756
757 static struct S
758 {
759 ubyte[] val = [1,2,3];
760 @property ref ubyte[] get(){ return val; }
761 alias get this;
762 }
763 S s;
764 foo(s);
765 }
766
767 /**********************************/
768 // 6208
769
getRefNonref(T)770 int getRefNonref(T)(ref T s){ return 1; }
getRefNonref(T)771 int getRefNonref(T)( T s){ return 2; }
772
getAutoRef(T)773 int getAutoRef(T)(auto ref T s){ return __traits(isRef, s) ? 1 : 2; }
774
getOut(T)775 void getOut(T)(out T s){ {} }
776
777 void getLazy1(T=int)(lazy void s){ s(), s(); }
getLazy2(T)778 void getLazy2(T)(lazy T s){ s(), s(); }
779
test6208a()780 void test6208a()
781 {
782 int lvalue;
783 int rvalue(){ int t; return t; }
784
785 assert(getRefNonref(lvalue ) == 1);
786 assert(getRefNonref(rvalue()) == 2);
787
788 assert(getAutoRef(lvalue ) == 1);
789 assert(getAutoRef(rvalue()) == 2);
790
791 static assert( __traits(compiles, getOut(lvalue )));
792 static assert(!__traits(compiles, getOut(rvalue())));
793
794 int n1; getLazy1(++n1); assert(n1 == 2);
795 int n2; getLazy2(++n2); assert(n2 == 2);
796
797 struct X
798 {
799 int f(T)(auto ref T t){ return 1; }
800 int f(T)(auto ref T t, ...){ return -1; }
801 }
802 auto xm = X ();
803 auto xc = const(X)();
804 int n;
805 assert(xm.f!int(n) == 1); // resolved 'auto ref'
806 assert(xm.f!int(0) == 1); // ditto
807 }
808
test6208b()809 void test6208b()
810 {
811 void foo(T)(const T value) if (!is(T == int)) {}
812
813 int mn;
814 const int cn;
815 static assert(!__traits(compiles, foo(mn))); // OK -> OK
816 static assert(!__traits(compiles, foo(cn))); // NG -> OK
817 }
818
test6208c()819 void test6208c()
820 {
821 struct S
822 {
823 // Original test case.
824 int foo(V)(in V v) { return 1; }
825 int foo(Args...)(auto ref const Args args) { return 2; }
826
827 // Reduced test cases
828
829 int hoo(V)(const V v) { return 1; } // typeof(10) : const V -> MATCHconst
830 int hoo(Args...)(const Args args) { return 2; } // typeof(10) : const Args[0] -> MATCHconst
831 // If deduction matching level is same, tuple parameter is less specialized than others.
832
833 int bar(V)(V v) { return 1; } // typeof(10) : V -> MATCHexact
834 int bar(Args...)(const Args args) { return 2; } // typeof(10) : const Args[0] -> MATCHconst
835
836 int baz(V)(const V v) { return 1; } // typeof(10) : const V -> MATCHconst
837 int baz(Args...)(Args args) { return 2; } // typeof(10) : Args[0] -> MATCHexact
838
839 inout(int) war(V)(inout V v) { return 1; }
840 inout(int) war(Args...)(inout Args args){ return 2; }
841
842 inout(int) waz(Args...)(inout Args args){ return 0; } // wild deduction test
843 }
844
845 S s;
846
847 int nm = 10;
848 assert(s.foo(nm) == 1);
849 assert(s.hoo(nm) == 1);
850 assert(s.bar(nm) == 1);
851 assert(s.baz(nm) == 2);
852 assert(s.war(nm) == 1);
853 static assert(is(typeof(s.waz(nm)) == int));
854
855 const int nc = 10;
856 assert(s.foo(nc) == 1);
857 assert(s.hoo(nc) == 1);
858 assert(s.bar(nc) == 1);
859 assert(s.baz(nc) == 1);
860 assert(s.war(nc) == 1);
861 static assert(is(typeof(s.waz(nc)) == const(int)));
862
863 immutable int ni = 10;
864 assert(s.foo(ni) == 1);
865 assert(s.hoo(ni) == 1);
866 assert(s.bar(ni) == 1);
867 assert(s.baz(ni) == 2);
868 assert(s.war(ni) == 1);
869 static assert(is(typeof(s.waz(ni)) == immutable(int)));
870
871 static assert(is(typeof(s.waz(nm, nm)) == int));
872 static assert(is(typeof(s.waz(nm, nc)) == const(int)));
873 static assert(is(typeof(s.waz(nm, ni)) == const(int)));
874 static assert(is(typeof(s.waz(nc, nm)) == const(int)));
875 static assert(is(typeof(s.waz(nc, nc)) == const(int)));
876 static assert(is(typeof(s.waz(nc, ni)) == const(int)));
877 static assert(is(typeof(s.waz(ni, nm)) == const(int)));
878 static assert(is(typeof(s.waz(ni, nc)) == const(int)));
879 static assert(is(typeof(s.waz(ni, ni)) == immutable(int)));
880 }
881
882 /**********************************/
883 // 6805
884
885 struct T6805
886 {
opDispatchT6805887 template opDispatch(string name)
888 {
889 alias int Type;
890 }
891 }
892 static assert(is(T6805.xxx.Type == int));
893
894 /**********************************/
895 // 6738
896
897 struct Foo6738
898 {
899 int _val = 10;
900
valFoo6738901 @property int val()() { return _val; }
getFoo6738902 int get() { return val; } // fail
903 }
904
test6738()905 void test6738()
906 {
907 Foo6738 foo;
908 auto x = foo.val; // ok
909 assert(x == 10);
910 assert(foo.get() == 10);
911 }
912
913 /**********************************/
914 // 7498
915
IndexMixin()916 template IndexMixin(){
917 void insert(T)(T value){ }
918 }
919
920 class MultiIndexContainer{
921 mixin IndexMixin!() index0;
922 class Index0{
baburk()923 void baburk(){
924 this.outer.index0.insert(1);
925 }
926 }
927 }
928
929 /**********************************/
930 // 6780
931
foo6780()932 @property int foo6780()(){ return 10; }
933
934 int g6780;
bar6780()935 @property void bar6780()(int n){ g6780 = n; }
936
test6780()937 void test6780()
938 {
939 auto n = foo6780;
940 assert(n == 10);
941
942 bar6780 = 10;
943 assert(g6780 == 10);
944 }
945
946 /**********************************/
947 // 6810
948
f6810(int n)949 int f6810(int n)(int) { return 1;}
f6810(U...)950 int f6810(U...)(U) { assert(0); }
f6810(U...)951 int f6810(U...)(U a) { assert(0); }
952 int f6810(U...)(U) if (true) { assert(0); }
953 int f6810(U...)(U a) if (true) { assert(0); }
954
test6810()955 void test6810()
956 {
957 assert(f6810!0(0) == 1);
958 }
959
960 /**********************************/
961 // 6891
962
S6891(int N,T)963 struct S6891(int N, T)
964 {
965 void f(U)(S6891!(N, U) u) { }
966 }
967
test6891()968 void test6891()
969 {
970 alias S6891!(1, void) A;
971 A().f(A());
972 }
973
974 /**********************************/
975 // 6994
976
977 struct Foo6994
978 {
getFoo6994979 T get(T)(){ return T.init; }
980
981 T func1(T)()
982 if (__traits(compiles, get!T()))
983 { return get!T; }
984
985 T func2(T)()
986 if (__traits(compiles, this.get!T())) // add explicit 'this'
987 { return get!T; }
988 }
test6994()989 void test6994()
990 {
991 Foo6994 foo;
992 foo.get!int(); // OK
993 foo.func1!int(); // OK
994 foo.func2!int(); // NG
995 }
996
997 /**********************************/
998 // 6764
999
1000 enum N6764 = 1; //use const for D1
1001
1002 alias size_t[N6764] T6764; //workaround
f6764()1003 void f6764()(T6764 arr...) { }
1004
g6764()1005 void g6764()(size_t[1] arr...) { }
1006
h6764()1007 void h6764()(size_t[N6764] arr...) { }
1008
test6764()1009 void test6764()
1010 {
1011 f6764(0); //good
1012 g6764(0); //good
1013 h6764!()(0); //good
1014 h6764(0); //Error: template main.f() does not match any function template declaration
1015 }
1016
1017 /**********************************/
1018 // 3467 & 6806
1019
Foo3467(uint n)1020 struct Foo3467( uint n )
1021 {
1022 Foo3467!( n ) bar( ) {
1023 typeof( return ) result;
1024 return result;
1025 }
1026 }
Vec3467(size_t N)1027 struct Vec3467(size_t N)
1028 {
1029 void opBinary(string op:"~", size_t M)(Vec3467!M) {}
1030 }
test3467()1031 void test3467()
1032 {
1033 Foo3467!( 4 ) baz;
1034 baz = baz.bar;// FAIL
1035
1036 Vec3467!2 a1;
1037 Vec3467!3 a2;
1038 a1 ~ a2; // line 7, Error
1039 }
1040
TS6806(size_t n)1041 struct TS6806(size_t n) { pragma(msg, typeof(n)); }
1042 static assert(is(TS6806!(1u) == TS6806!(1)));
1043
1044 /**********************************/
1045 // 4413
1046
1047 struct Foo4413
1048 {
1049 alias typeof(this) typeof_this;
bar1Foo44131050 void bar1(typeof_this other) {}
bar2Foo44131051 void bar2()(typeof_this other) {}
bar3Foo44131052 void bar3(typeof(this) other) {}
bar4Foo44131053 void bar4()(typeof(this) other) {}
1054 }
1055
test4413()1056 void test4413()
1057 {
1058 Foo4413 f;
1059 f.bar1(f); // OK
1060 f.bar2(f); // OK
1061 f.bar3(f); // OK
1062 f.bar4(f); // ERR
1063 }
1064
1065 /**********************************/
1066 // 4675
1067
isNumeric(T)1068 template isNumeric(T)
1069 {
1070 enum bool test1 = is(T : long); // should be hidden
1071 enum bool test2 = is(T : real); // should be hidden
1072 enum bool isNumeric = test1 || test2;
1073 }
test4675()1074 void test4675()
1075 {
1076 static assert( isNumeric!int);
1077 static assert(!isNumeric!string);
1078 static assert(!__traits(compiles, isNumeric!int.test1)); // should be an error
1079 static assert(!__traits(compiles, isNumeric!int.test2)); // should be an error
1080 static assert(!__traits(compiles, isNumeric!int.isNumeric));
1081 }
1082
1083 /**********************************/
1084 // 5525
1085
foo5525(T)1086 template foo5525(T)
1087 {
1088 T foo5525(T t) { return t; }
1089 T foo5525(T t, T u) { return t + u; }
1090 }
1091
test5525()1092 void test5525()
1093 {
1094 alias foo5525!int f;
1095 assert(f(1) == 1);
1096 assert(f(1, 2) == 3);
1097 }
1098
1099 /**********************************/
1100 // 5801
1101
1102 int a5801;
typeof(a5801)1103 void bar5801(T = double)(typeof(a5801) i) {}
baz5801(T)1104 void baz5801(T)(typeof(a5801) i, T t) {}
test5801()1105 void test5801()
1106 {
1107 bar5801(2); // Does not compile.
1108 baz5801(3, "baz"); // Does not compile.
1109 }
1110
1111 /**********************************/
1112 // 5832
1113
Bar5832(alias v)1114 struct Bar5832(alias v) {}
1115
isBar5832a(T)1116 template isBar5832a(T)
1117 {
1118 static if (is(T _ : Bar5832!(v), alias v))
1119 enum isBar5832a = true;
1120 else
1121 enum isBar5832a = false;
1122 }
isBar5832b(T)1123 template isBar5832b(T)
1124 {
1125 static if (is(T _ : Bar5832!(v), alias int v))
1126 enum isBar5832b = true;
1127 else
1128 enum isBar5832b = false;
1129 }
isBar5832c(T)1130 template isBar5832c(T)
1131 {
1132 static if (is(T _ : Bar5832!(v), alias string v))
1133 enum isBar5832c = true;
1134 else
1135 enum isBar5832c = false;
1136 }
1137 static assert( isBar5832a!(Bar5832!1234));
1138 static assert( isBar5832b!(Bar5832!1234));
1139 static assert(!isBar5832c!(Bar5832!1234));
1140
1141 /**********************************/
1142 // 2550
1143
pow10_2550(long n)1144 template pow10_2550(long n)
1145 {
1146 const long pow10_2550 = 0;
1147 static if (n < 0)
1148 const long pow10_2550 = 0;
1149 else
1150 const long pow10_2550 = 10 * pow10_2550!(n - 1);
1151 }
1152 template pow10_2550(long n:0)
1153 {
1154 const long pow10_2550 = 1;
1155 }
1156 static assert(pow10_2550!(0) == 1);
1157
1158 /**********************************/
1159 // [2.057] Remove top const in IFTI, 9198
1160
foo10a(T)1161 void foo10a(T )(T) { static assert(is(T == const(int)[])); }
foo10b(T...)1162 void foo10b(T...)(T) { static assert(is(T[0] == const(int)[])); }
1163
1164 // ref parameter doesn't remove top const
boo10a(T)1165 void boo10a(T )(ref T) { static assert(is(T == const(int[]))); }
boo10b(T...)1166 void boo10b(T...)(ref T) { static assert(is(T[0] == const(int[]))); }
1167
1168 // auto ref with lvalue doesn't
goo10a(T)1169 void goo10a(T )(auto ref T) { static assert(is(T == const(int[]))); }
goo10b(T...)1170 void goo10b(T...)(auto ref T) { static assert(is(T[0] == const(int[]))); }
1171
1172 // auto ref with rvalue does
hoo10a(T)1173 void hoo10a(T )(auto ref T) { static assert(is(T == const(int)[])); }
hoo10b(T...)1174 void hoo10b(T...)(auto ref T) { static assert(is(T[0] == const(int)[])); }
1175
bar10a(T)1176 void bar10a(T )(T) { static assert(is(T == const(int)*)); }
bar10b(T...)1177 void bar10b(T...)(T) { static assert(is(T[0] == const(int)*)); }
1178
test10()1179 void test10()
1180 {
1181 const a = [1,2,3];
1182 static assert(is(typeof(a) == const(int[])));
1183 foo10a(a);
1184 foo10b(a);
1185 boo10a(a);
1186 boo10b(a);
1187 goo10a(a);
1188 goo10b(a);
1189 hoo10a(cast(const)[1,2,3]);
1190 hoo10b(cast(const)[1,2,3]);
1191
1192 int n;
1193 const p = &n;
1194 static assert(is(typeof(p) == const(int*)));
1195 bar10a(p);
1196 bar10b(p);
1197 }
1198
1199 /**********************************/
1200 // 3092
1201
Foo3092(A...)1202 template Foo3092(A...)
1203 {
1204 alias A[0] Foo3092;
1205 }
1206 static assert(is(Foo3092!(int, "foo") == int));
1207
1208 /**********************************/
1209 // 7037
1210
1211 struct Foo7037 {}
1212 struct Bar7037 { Foo7037 f; alias f this; }
1213 void works7037( T )( T value ) if ( is( T : Foo7037 ) ) {}
1214 void doesnotwork7037( T : Foo7037 )( T value ) {}
1215
test7037()1216 void test7037()
1217 {
1218 Bar7037 b;
1219 works7037( b );
1220 doesnotwork7037( b );
1221 }
1222
1223 /**********************************/
1224 // 7110
1225
1226 struct S7110
1227 {
opSliceS71101228 int opSlice(int, int) const { return 0; }
opSliceS71101229 int opSlice() const { return 0; }
opIndexS71101230 int opIndex(int, int) const { return 0; }
opIndexS71101231 int opIndex(int) const { return 0; }
1232 }
1233
1234 enum e7110 = S7110();
1235
T7110(alias a)1236 template T7110(alias a) { } // or T7110(a...)
1237
1238 alias T7110!( S7110 ) T71100; // passes
1239 alias T7110!((S7110)) T71101; // passes
1240
1241 alias T7110!( S7110()[0..0] ) A0; // passes
1242 alias T7110!( (e7110[0..0]) ) A1; // passes
1243 alias T7110!( e7110[0..0] ) A2; // passes
1244
1245 alias T7110!( S7110()[0, 0] ) B0; // passes
1246 alias T7110!( (e7110[0, 0]) ) B1; // passes
1247 alias T7110!( e7110[0, 0] ) B2; // passes
1248
1249 alias T7110!( S7110()[] ) C0; // passes
1250 alias T7110!( (e7110[]) ) C1; // passes
1251 alias T7110!( e7110[] ) C2; // fails: e7110 is used as a type
1252
1253 alias T7110!( S7110()[0] ) D0; // passes
1254 alias T7110!( (e7110[0]) ) D1; // passes
1255 alias T7110!( e7110[0] ) D2; // fails: e7110 must be an array or pointer type, not S7110
1256
1257 /**********************************/
1258 // 7124
1259
1260 template StaticArrayOf(T : E[dim], E, size_t dim)
1261 {
1262 pragma(msg, "T = ", T, ", E = ", E, ", dim = ", dim);
1263 alias E[dim] StaticArrayOf;
1264 }
1265
1266 template DynamicArrayOf(T : E[], E)
1267 {
1268 pragma(msg, "T = ", T, ", E = ", E);
1269 alias E[] DynamicArrayOf;
1270 }
1271
1272 template AssocArrayOf(T : V[K], K, V)
1273 {
1274 pragma(msg, "T = ", T, ", K = ", K, ", V = ", V);
1275 alias V[K] AssocArrayOf;
1276 }
test7124()1277 void test7124()
1278 {
1279 struct SA { int[5] sa; alias sa this; }
1280 static assert(is(StaticArrayOf!SA == int[5]));
1281
1282 struct DA { int[] da; alias da this; }
1283 static assert(is(DynamicArrayOf!DA == int[]));
1284
1285 struct AA { int[string] aa; alias aa this; }
1286 static assert(is(AssocArrayOf!AA == int[string]));
1287 }
1288
1289 /**********************************/
1290 // 7359
1291
foo7359(T)1292 bool foo7359(T)(T[] a ...)
1293 {
1294 return true;
1295 }
1296
test7359()1297 void test7359()
1298 {
1299 assert(foo7359(1,1,1,1,1,1)); // OK
1300 assert(foo7359("abc","abc","abc","abc")); // NG
1301 }
1302
1303 /**********************************/
1304 // 7363
1305
t7363()1306 template t7363()
1307 {
1308 enum e = 0;
1309 static if (true)
1310 enum t7363 = 0;
1311 }
1312 static assert(!__traits(compiles, t7363!().t7363 == 0)); // Assertion fails
1313 static assert(t7363!() == 0); // Error: void has no value
1314
u7363()1315 template u7363()
1316 {
1317 static if (true)
1318 {
1319 enum e = 0;
1320 enum u73631 = 0;
1321 }
1322 alias u73631 u7363;
1323 }
1324 static assert(!__traits(compiles, u7363!().u7363 == 0)); // Assertion fails
1325 static assert(u7363!() == 0); // Error: void has no value
1326
1327 /**********************************/
1328
S4371(T...)1329 struct S4371(T ...) { }
1330
1331 alias S4371!("hi!") t;
1332
1333 static if (is(t U == S4371!(U))) { }
1334
1335 /**********************************/
1336 // 7416
1337
1338 void t7416(alias a)() if(is(typeof(a())))
1339 {}
1340
test7416()1341 void test7416() {
1342 void f() {}
1343 alias t7416!f x;
1344 }
1345
1346 /**********************************/
1347 // 7563
1348
1349 class Test7563
1350 {
1351 void test(T, bool a = true)(T t)
1352 {
1353
1354 }
1355 }
1356
test7563()1357 void test7563()
1358 {
1359 auto test = new Test7563;
1360 pragma(msg, typeof(test.test!(int, true)).stringof);
1361 pragma(msg, typeof(test.test!(int)).stringof); // Error: expression (test.test!(int)) has no type
1362 }
1363
1364 /**********************************/
1365 // 7572
1366
1367 class F7572
1368 {
fn7572(Tr,T...)1369 Tr fn7572(Tr, T...)(T t) { return 1; }
1370 }
Fn7572(Tr,T...)1371 Tr Fn7572(Tr, T...)(T t) { return 2; }
1372
test7572()1373 void test7572()
1374 {
1375 F7572 f = new F7572();
1376 int delegate() dg = &f.fn7572!int;
1377 assert(dg() == 1);
1378
1379 int function() fn = &Fn7572!int;
1380 assert(fn() == 2);
1381 }
1382
1383 /**********************************/
1384 // 7580
1385
S7580(T)1386 struct S7580(T)
1387 {
1388 void opAssign()(T value) {}
1389 }
X7580(T)1390 struct X7580(T)
1391 {
1392 private T val;
1393 @property ref inout(T) get()() inout { return val; } // template
1394 alias get this;
1395 }
Y7580(T)1396 struct Y7580(T)
1397 {
1398 private T val;
1399 @property ref auto get()() inout { return val; } // template + auto return
1400 alias get this;
1401 }
1402
test7580()1403 void test7580()
1404 {
1405 S7580!(int) s;
1406 X7580!int x;
1407 Y7580!int y;
1408 s = x;
1409 s = y;
1410
1411 shared(X7580!int) sx;
1412 static assert(!__traits(compiles, s = sx));
1413 }
1414
1415 /**********************************/
1416 // 7585
1417
1418 extern(C) alias void function() Callback;
1419
W7585a(alias dg)1420 template W7585a(alias dg)
1421 {
1422 //pragma(msg, typeof(dg));
1423 extern(C) void W7585a() { dg(); }
1424 }
1425
test7585()1426 void test7585()
1427 {
1428 static void f7585a(){}
1429 Callback cb1 = &W7585a!(f7585a); // OK
1430 static assert(!__traits(compiles,
1431 {
1432 void f7585b(){}
1433 Callback cb2 = &W7585a!(f7585b); // NG
1434 }));
1435
1436 Callback cb3 = &W7585a!((){}); // NG -> OK
1437 Callback cb4 = &W7585a!(function(){}); // OK
1438 static assert(!__traits(compiles,
1439 {
1440 Callback cb5 = &W7585a!(delegate(){}); // NG
1441 }));
1442
1443 static int global; // global data
1444 Callback cb6 = &W7585a!((){return global;}); // NG -> OK
1445 static assert(!__traits(compiles,
1446 {
1447 int n;
1448 Callback cb7 = &W7585a!((){return n;}); // NG
1449 }));
1450 }
1451
1452 /**********************************/
1453 // 7643
1454
T7643(A...)1455 template T7643(A...){ alias A T7643; }
1456
1457 alias T7643!(long, "x", string, "y") Specs7643;
1458
1459 alias T7643!( Specs7643[] ) U7643; // Error: tuple A is used as a type
1460
1461 /**********************************/
1462 // 7671
1463
1464 inout(int)[3] id7671n1 ( inout(int)[3] );
1465 inout( U )[n] id7671x1(U, size_t n)( inout( U )[n] );
1466
1467 shared(inout int)[3] id7671n2 ( shared(inout int)[3] );
1468 shared(inout U )[n] id7671x2(U, size_t n)( shared(inout U )[n] );
1469
test7671()1470 void test7671()
1471 {
1472 static assert(is( typeof( id7671n1( (immutable(int)[3]).init ) ) == immutable(int[3]) ));
1473 static assert(is( typeof( id7671x1( (immutable(int)[3]).init ) ) == immutable(int[3]) ));
1474
1475 static assert(is( typeof( id7671n2( (immutable(int)[3]).init ) ) == immutable(int[3]) ));
1476 static assert(is( typeof( id7671x2( (immutable(int)[3]).init ) ) == immutable(int[3]) ));
1477 }
1478
1479 /************************************/
1480 // 7672
1481
foo7672(T)1482 T foo7672(T)(T a){ return a; }
1483
inout(int[])1484 void test7672(inout(int[]) a = null, inout(int*) p = null)
1485 {
1486 static assert(is( typeof( a ) == inout(int[]) ));
1487 static assert(is( typeof(foo7672(a)) == inout(int)[] ));
1488
1489 static assert(is( typeof( p ) == inout(int*) ));
1490 static assert(is( typeof(foo7672(p)) == inout(int)* ));
1491 }
1492
1493 /**********************************/
1494 // 7684
1495
1496 U[] id7684(U)( U[] );
1497 shared(U[]) id7684(U)( shared(U[]) );
1498
test7684()1499 void test7684()
1500 {
1501 shared(int)[] x;
1502 static assert(is( typeof(id7684(x)) == shared(int)[] ));
1503 }
1504
1505 /**********************************/
1506 // 7694
1507
match7694(alias m)1508 void match7694(alias m)()
1509 {
1510 m.foo(); //removing this line suppresses ice in both cases
1511 }
1512
1513 struct T7694
1514 {
fooT76941515 void foo(){}
bootstrapT76941516 void bootstrap()
1517 {
1518 //next line causes ice
1519 match7694!(this)();
1520 //while this works:
1521 alias this p;
1522 match7694!(p)();
1523 }
1524 }
1525
1526 /**********************************/
1527 // 7755
1528
to7755(T)1529 template to7755(T)
1530 {
1531 T to7755(A...)(A args)
1532 {
1533 return toImpl7755!T(args);
1534 }
1535 }
1536
toImpl7755(T,S)1537 T toImpl7755(T, S)(S value)
1538 {
1539 return T.init;
1540 }
1541
Foo7755(T)1542 template Foo7755(T){}
1543
1544 struct Bar7755
1545 {
quxBar77551546 void qux()
1547 {
1548 if (is(typeof(to7755!string(Foo7755!int)))){}
1549 }
1550 }
1551
1552 /**********************************/
1553
1554 U[] id11a(U)( U[] );
1555 inout(U)[] id11a(U)( inout(U)[] );
1556 inout(U[]) id11a(U)( inout(U[]) );
1557 inout(shared(U[])) id11a(U)( inout(shared(U[])) );
1558
1559 void test11a(inout int _ = 0)
1560 {
1561 shared(const(int))[] x;
1562 static assert(is( typeof(id11a(x)) == shared(const(int))[] ));
1563
1564 shared(int)[] y;
1565 static assert(is( typeof(id11a(y)) == shared(int)[] ));
1566
1567 inout(U)[n] idz(U, size_t n)( inout(U)[n] );
1568
1569 inout(shared(bool[1])) z;
1570 static assert(is( typeof(idz(z)) == inout(shared(bool[1])) ));
1571 }
1572
1573 inout(U[]) id11b(U)( inout(U[]) );
1574
test11b()1575 void test11b()
1576 {
1577 alias const(shared(int)[]) T;
1578 static assert(is(typeof(id11b(T.init)) == const(shared(int)[])));
1579 }
1580
1581 /**********************************/
1582 // 7769
1583
f7769(K)1584 void f7769(K)(inout(K) value){}
test7769()1585 void test7769()
1586 {
1587 f7769("abc");
1588 }
1589
1590 /**********************************/
1591 // 7812
1592
A7812(T...)1593 template A7812(T...) {}
1594
1595 template B7812(alias C) if (C) {}
1596
D7812()1597 template D7812()
1598 {
1599 alias B7812!(A7812!(NonExistent!())) D7812;
1600 }
1601
1602 static assert(!__traits(compiles, D7812!()));
1603
1604 /**********************************/
1605 // 7873
1606
inout(T)1607 inout(T)* foo(T)(inout(T)* t)
1608 {
1609 static assert(is(T == int*));
1610 return t;
1611 }
1612
inout(T)1613 inout(T)* bar(T)(inout(T)* t)
1614 {
1615 return foo(t);
1616 }
1617
test7873()1618 void test7873()
1619 {
1620 int *i;
1621 bar(&i);
1622 }
1623
1624 /**********************************/
1625 // 7933
1626
Boo7933(size_t dim)1627 struct Boo7933(size_t dim){int a;}
Baa7933(size_t dim)1628 struct Baa7933(size_t dim)
1629 {
1630 Boo7933!dim a;
1631 //Boo7933!1 a; //(1) This version causes no errors
1632 }
1633
foo7933()1634 auto foo7933()(Boo7933!1 b){return b;}
1635 //auto fuu7933(Boo7933!1 b){return b;} //(2) This line neutralizes the error
1636
test7933()1637 void test7933()
1638 {
1639 Baa7933!1 a; //(3) This line causes the error message
1640 auto b = foo7933(Boo7933!1(1));
1641 }
1642
1643 /**********************************/
1644 // 8094
1645
Tuple8094(T...)1646 struct Tuple8094(T...) {}
1647
getParameters8094(T,alias P)1648 template getParameters8094(T, alias P)
1649 {
1650 static if (is(T t == P!U, U...))
1651 alias U getParameters8094;
1652 else
1653 static assert(false);
1654 }
1655
test8094()1656 void test8094()
1657 {
1658 alias getParameters8094!(Tuple8094!(int, string), Tuple8094) args;
1659 }
1660
1661 /**********************************/
1662
Tuple12(T...)1663 struct Tuple12(T...)
1664 {
1665 void foo(alias P)()
1666 {
1667 alias Tuple12 X;
1668 static if (is(typeof(this) t == X!U, U...))
1669 alias U getParameters;
1670 else
1671 static assert(false);
1672 }
1673 }
1674
test12()1675 void test12()
1676 {
1677 Tuple12!(int, string) t;
1678 t.foo!Tuple12();
1679 }
1680
1681 /**********************************/
1682 // 14290
1683
Foo14290(int i)1684 struct Foo14290(int i) {}
1685 alias Foo14290a = Foo14290!1;
1686 static assert(!is(Foo14290!2 == Foo14290a!T, T...));
1687
1688 /**********************************/
1689 // 8125
1690
foo8125()1691 void foo8125(){}
1692
X8125(alias a)1693 struct X8125(alias a) {}
1694
1695 template Y8125a(T : A!f, alias A, alias f) {} //OK
1696 template Y8125b(T : A!foo8125, alias A) {} //NG
1697
test8125()1698 void test8125()
1699 {
1700 alias Y8125a!(X8125!foo8125) y1;
1701 alias Y8125b!(X8125!foo8125) y2;
1702 }
1703
1704 /**********************************/
1705
A13()1706 struct A13() {}
B13(TT...)1707 struct B13(TT...) {}
C13(T1)1708 struct C13(T1) {}
D13(T1,TT...)1709 struct D13(T1, TT...) {}
E13(T1,T2)1710 struct E13(T1, T2) {}
F13(T1,T2,TT...)1711 struct F13(T1, T2, TT...) {}
1712
Test13(alias X)1713 template Test13(alias X)
1714 {
1715 static if (is(X x : P!U, alias P, U...))
1716 enum Test13 = true;
1717 else
1718 enum Test13 = false;
1719 }
1720
test13()1721 void test13()
1722 {
1723 static assert(Test13!( A13!() ));
1724 static assert(Test13!( B13!(int) ));
1725 static assert(Test13!( B13!(int, double) ));
1726 static assert(Test13!( B13!(int, double, string) ));
1727 static assert(Test13!( C13!(int) ));
1728 static assert(Test13!( D13!(int) ));
1729 static assert(Test13!( D13!(int, double) ));
1730 static assert(Test13!( D13!(int, double, string) ));
1731 static assert(Test13!( E13!(int, double) ));
1732 static assert(Test13!( F13!(int, double) ));
1733 static assert(Test13!( F13!(int, double, string) ));
1734 static assert(Test13!( F13!(int, double, string, bool) ));
1735 }
1736
1737 /**********************************/
1738
1739 struct A14(T, U, int n = 1)
1740 {
1741 }
1742
Test14(alias X)1743 template Test14(alias X)
1744 {
1745 static if (is(X x : P!U, alias P, U...))
1746 alias U Test14;
1747 else
1748 static assert(0);
1749 }
1750
test14()1751 void test14()
1752 {
1753 alias A14!(int, double) Type;
1754 alias Test14!Type Params;
1755 static assert(Params.length == 3);
1756 static assert(is(Params[0] == int));
1757 static assert(is(Params[1] == double));
1758 static assert( Params[2] == 1);
1759 }
1760
1761 /**********************************/
1762 // test for evaluateConstraint assertion
1763
1764 bool canSearchInCodeUnits15(C)(dchar c)
1765 if (is(C == char))
1766 {
1767 return true;
1768 }
1769
test15()1770 void test15()
1771 {
1772 int needle = 0;
1773 auto b = canSearchInCodeUnits15!char(needle);
1774 }
1775
1776 /**********************************/
1777 // 8129
1778
1779 class X8129 {}
1780 class A8129 {}
1781 class B8129 : A8129 {}
1782
1783 int foo8129(T : A8129)(X8129 x) { return 1; }
1784 int foo8129(T : A8129)(X8129 x, void function (T) block) { return 2; }
1785
bar8129(T,R)1786 int bar8129(T, R)(R range, T value) { return 1; }
1787
baz8129(T,R)1788 int baz8129(T, R)(R range, T value) { return 1; }
baz8129(T,R)1789 int baz8129(T, R)(R range, Undefined value) { return 2; }
1790
test8129()1791 void test8129()
1792 {
1793 auto x = new X8129;
1794 assert(x.foo8129!B8129() == 1);
1795 assert(x.foo8129!B8129((a){}) == 2);
1796 assert(foo8129!B8129(x) == 1);
1797 assert(foo8129!B8129(x, (a){}) == 2);
1798 assert(foo8129!B8129(x) == 1);
1799 assert(foo8129!B8129(x, (B8129 b){}) == 2);
1800
1801 ubyte[] buffer = [0, 1, 2];
1802 assert(bar8129!ushort(buffer, 915) == 1);
1803
1804 // While deduction, parameter type 'Undefined' shows semantic error.
1805 static assert(!__traits(compiles, {
1806 baz8129!ushort(buffer, 915);
1807 }));
1808 }
1809
1810 /**********************************/
1811 // 8238
1812
test8238()1813 void test8238()
1814 {
1815 static struct S { template t(){ int t; } }
1816
1817 S s1, s2;
1818 assert(cast(void*)&s1 != cast(void*)&s2 );
1819 assert(cast(void*)&s1 != cast(void*)&s1.t!());
1820 assert(cast(void*)&s2 != cast(void*)&s2.t!());
1821 assert(cast(void*)&s1.t!() == cast(void*)&s2.t!());
1822 s1.t!() = 256;
1823 assert(s2.t!() == 256);
1824 }
1825
1826 /**********************************/
1827 // 8669
1828
1829 struct X8669
1830 {
mfooX86691831 void mfoo(this T)()
1832 {
1833 static assert(is(typeof(this) == T));
1834 }
cfooX86691835 void cfoo(this T)() const
1836 {
1837 static assert(is(typeof(this) == const(T)));
1838 }
sfooX86691839 void sfoo(this T)() shared
1840 {
1841 static assert(is(typeof(this) == shared(T)));
1842 }
scfooX86691843 void scfoo(this T)() shared const
1844 {
1845 static assert(is(typeof(this) == shared(const(T))));
1846 }
ifooX86691847 void ifoo(this T)() immutable
1848 {
1849 static assert(is(typeof(this) == immutable(T)));
1850 }
1851 }
1852
test8669()1853 void test8669()
1854 {
1855 X8669 mx;
1856 const X8669 cx;
1857 immutable X8669 ix;
1858 shared X8669 sx;
1859 shared const X8669 scx;
1860
1861 mx.mfoo();
1862 cx.mfoo();
1863 ix.mfoo();
1864 sx.mfoo();
1865 scx.mfoo();
1866
1867 mx.cfoo();
1868 cx.cfoo();
1869 ix.cfoo();
1870 sx.cfoo();
1871 scx.cfoo();
1872
1873 static assert(!is(typeof( mx.sfoo() )));
1874 static assert(!is(typeof( cx.sfoo() )));
1875 ix.sfoo();
1876 sx.sfoo();
1877 scx.sfoo();
1878
1879 static assert(!is(typeof( mx.scfoo() )));
1880 static assert(!is(typeof( cx.scfoo() )));
1881 ix.scfoo();
1882 sx.scfoo();
1883 scx.scfoo();
1884
1885 static assert(!is(typeof( mx.ifoo() )));
1886 static assert(!is(typeof( cx.ifoo() )));
1887 ix.ifoo();
1888 static assert(!is(typeof( sx.ifoo() )));
1889 static assert(!is(typeof( scx.ifoo() )));
1890 }
1891
1892 /**********************************/
1893 // 8833
1894
TypeTuple8833(T...)1895 template TypeTuple8833(T...) { alias TypeTuple = T; }
1896
func8833(alias arg)1897 void func8833(alias arg)() { }
1898
test8833()1899 void test8833()
1900 {
1901 int x, y;
1902
1903 alias TypeTuple8833!(
1904 func8833!(x),
1905 func8833!(y),
1906 ) Map;
1907 }
1908
1909 /**********************************/
1910 // 8976
1911
f8976(ref int)1912 void f8976(ref int) { }
1913
g8976()1914 void g8976()()
1915 {
1916 f8976(0); // line 5
1917 }
1918
1919
h8976()1920 void h8976()()
1921 {
1922 g8976!()();
1923 }
1924
1925 static assert(! __traits(compiles, h8976!()() ) ); // causes error
1926 static assert(!is(typeof( h8976!()() )));
1927
test8976()1928 void test8976()
1929 {
1930 static assert(! __traits(compiles, h8976!()() ) );
1931 static assert(!is(typeof( h8976!()() )));
1932 }
1933
1934 /****************************************/
1935 // 8940
1936
1937 const int n8940; // or `immutable`
this()1938 static this() { n8940 = 3; }
1939
f8940(T)1940 void f8940(T)(ref int val)
1941 {
1942 assert(val == 3);
1943 ++val;
1944 }
1945
1946 static assert(!__traits(compiles, f8940!void(n8940))); // fails
test8940()1947 void test8940()
1948 {
1949 assert(n8940 == 3);
1950 static assert(!__traits(compiles, f8940!void(n8940)));
1951 //assert(n8940 == 3); // may pass as compiler caches comparison result
1952 //assert(n8940 != 4); // may pass but likely will fail
1953 }
1954
1955 /**********************************/
1956 // 6969 + 8990
1957
A6969()1958 class A6969() { alias C6969!() C1; }
1959 class B6969 { alias A6969!() A1; }
C6969()1960 class C6969() : B6969 {}
1961
A8990(T)1962 struct A8990(T) { T t; }
B8990(T)1963 struct B8990(T) { A8990!T* a; }
1964 struct C8990 { B8990!C8990* b; }
1965
1966 /**********************************/
1967 // 9018
1968
Inst9018(alias Template,T)1969 template Inst9018(alias Template, T)
1970 {
1971 alias Template!T Inst;
1972 }
1973
Template9018(T)1974 template Template9018(T)
1975 {
1976 enum Template9018 = T;
1977 }
1978
1979 static assert(!__traits(compiles, Inst9018!(Template9018, int))); // Assert passes
1980 static assert(!__traits(compiles, Inst9018!(Template9018, int))); // Assert fails
1981
1982 /**********************************/
1983 // 9022
1984
1985 class C9022
1986 {
1987 struct X {}
1988
1989 alias B = X;
1990 }
1991 class D9022
1992 {
1993 struct X {}
1994 }
1995
1996 void test9022()
1997 {
1998 auto c = new C9022();
1999 auto d = new D9022();
2000 auto cx = C9022.X();
2001 auto dx = D9022.X();
2002
2003 void foo1(T)(T, T.X) { static assert(is(T == C9022)); }
2004 void foo2(T)(T.X, T) { static assert(is(T == C9022)); }
2005 foo1(c, cx);
2006 foo2(cx, c);
2007
2008 void hoo1(T)(T, T.B) { static assert(is(T == C9022)); }
2009 void hoo2(T)(T.B, T) { static assert(is(T == C9022)); }
2010 hoo1(c, cx);
2011 hoo1(c, cx);
2012
2013 void bar1(alias A)(A.C9022, A.D9022) { static assert(A.stringof == "module breaker"); }
2014 void bar2(alias A)(A.D9022, A.C9022) { static assert(A.stringof == "module breaker"); }
2015 bar1(c, d);
2016 bar2(d, c);
2017
2018 void var1(alias A)(A.C9022, A.D9022.X) { static assert(A.stringof == "module breaker"); }
2019 void var2(alias A)(A.D9022.X, A.C9022) { static assert(A.stringof == "module breaker"); }
2020 var1(c, dx);
2021 var2(dx, c);
2022
2023 void baz(T)(T.X t, T.X u) { }
2024 static assert(!__traits(compiles, baz(cx, dx)));
2025 }
2026
2027 /**********************************/
2028 // 9026
2029
2030 mixin template node9026()
2031 {
2032 static if (is(this == struct))
2033 alias typeof(this)* E;
2034 else
2035 alias typeof(this) E;
2036 E prev, next;
2037 }
2038
2039 struct list9026(alias N)
2040 {
2041 N.E head;
2042 N.E tail;
2043 }
2044
2045 class A9026
2046 {
2047 mixin node9026 L1;
2048 mixin node9026 L2;
2049 }
2050
2051 list9026!(A9026.L1) g9026_l1;
2052 list9026!(A9026.L2) g9026_l2;
2053
2054 void test9026()
2055 {
2056 list9026!(A9026.L1) l9026_l1;
2057 list9026!(A9026.L2) l9026_l2;
2058 }
2059
2060 /**********************************/
2061 // 9038
2062
2063 mixin template Foo9038()
2064 {
2065 string data = "default";
2066 }
2067
2068 class Bar9038
2069 {
2070 string data;
2071 mixin Foo9038 f;
2072 }
2073
2074 void check_data9038(alias M, T)(T obj)
2075 {
2076 //writeln(M.stringof);
2077 assert(obj.data == "Bar");
2078 assert(obj.f.data == "F");
2079 }
2080
2081 void test9038()
2082 {
2083 auto bar = new Bar9038;
2084 bar.data = "Bar";
2085 bar.f.data = "F";
2086
2087 assert(bar.data == "Bar");
2088 assert(bar.f.data == "F");
2089
2090 check_data9038!(Bar9038)(bar);
2091 check_data9038!(Bar9038.f)(bar);
2092 check_data9038!(bar.f)(bar);
2093 }
2094
2095 /**********************************/
2096 // 9050
2097
2098 struct A9050(T) {}
2099
2100 struct B9050(T)
2101 {
2102 void f() { foo9050(A9050!int()); }
2103 }
2104
2105 auto foo9050()(A9050!int base) pure
2106 {
2107 return B9050!int();
2108 }
2109
2110 auto s9050 = foo9050(A9050!int());
2111
2112 /**********************************/
2113 // 10936 (dup of 9050)
2114
2115 struct Vec10936(string s)
2116 {
2117 auto foo(string v)()
2118 {
2119 return Vec10936!(v)();
2120 }
2121
2122 static void bar()
2123 {
2124 Vec10936!"" v;
2125 auto p = v.foo!"sup";
2126 }
2127 }
2128
2129 Vec10936!"" v;
2130
2131 /**********************************/
2132 // 9076
2133
2134 template forward9076(args...)
2135 {
2136 @property forward9076()(){ return args[0]; }
2137 }
2138
2139 void test9076()
2140 {
2141 int a = 1;
2142 int b = 1;
2143 assert(a == forward9076!b);
2144 }
2145
2146 /**********************************/
2147 // 9083
2148
2149 template isFunction9083(X...) if (X.length == 1)
2150 {
2151 enum isFunction9083 = true;
2152 }
2153
2154 struct S9083
2155 {
2156 static string func(alias Class)()
2157 {
2158 foreach (m; __traits(allMembers, Class))
2159 {
2160 pragma(msg, m); // prints "func"
2161 enum x1 = isFunction9083!(mixin(m)); //NG
2162 enum x2 = isFunction9083!(func); //OK
2163 }
2164 return "";
2165 }
2166 }
2167 enum nothing9083 = S9083.func!S9083();
2168
2169 class C9083
2170 {
2171 int x; // some class members
2172
2173 void func()
2174 {
2175 void templateFunc(T)(const T obj)
2176 {
2177 enum x1 = isFunction9083!(mixin("x")); // NG
2178 enum x2 = isFunction9083!(x); // NG
2179 }
2180 templateFunc(this);
2181 }
2182 }
2183
2184 /**********************************/
2185 // 9100
2186
2187 template Id(alias A) { alias Id = A; }
2188 template ErrId(alias A) { static assert(0); }
2189 template TypeTuple9100(TL...) { alias TypeTuple9100 = TL; }
2190
2191 class C9100
2192 {
2193 int value;
2194
2195 int fun() { return value; }
2196 int tfun(T)() { return value; }
2197 TypeTuple9100!(int, long) field;
2198
2199 void test()
2200 {
2201 this.value = 1;
2202 auto c = new C9100();
2203 c.value = 2;
2204
2205 alias t1a = Id!(c.fun); // OK
2206 alias t1b = Id!(this.fun); // Prints weird error, bad
2207 // -> internally given TOKdotvar
2208 assert(t1a() == this.value);
2209 assert(t1b() == this.value);
2210
2211 alias t2a = Id!(c.tfun); // OK
2212 static assert(!__traits(compiles, ErrId!(this.tfun)));
2213 alias t2b = Id!(this.tfun); // No error occurs, why?
2214 // -> internally given TOKdottd
2215 assert(t2a!int() == this.value);
2216 assert(t2b!int() == this.value);
2217
2218 alias t3a = Id!(foo9100); // OK
2219 alias t3b = Id!(mixin("foo9100")); // Prints weird error, bad
2220 // -> internally given TOKtemplate
2221 assert(t3a() == 10);
2222 assert(t3b() == 10);
2223
2224 assert(field[0] == 0);
2225 alias t4a = TypeTuple9100!(field); // NG
2226 alias t4b = TypeTuple9100!(GetField9100!()); // NG
2227 t4a[0] = 1; assert(field[0] == 1);
2228 t4b[0] = 2; assert(field[0] == 2);
2229 }
2230 }
2231
2232 int foo9100()() { return 10; }
2233 template GetField9100() { alias GetField9100 = C9100.field[0]; }
2234
2235 void test9100()
2236 {
2237 (new C9100()).test();
2238 }
2239
2240 /**********************************/
2241 // 9101
2242
2243 class Node9101
2244 {
2245 template ForwardCtorNoId()
2246 {
2247 this() {} // default constructor
2248 void foo() { 0 = 1; } // wrong code
2249 }
2250 }
2251 enum x9101 = __traits(compiles, Node9101.ForwardCtorNoId!());
2252
2253 /**********************************/
2254 // 9124
2255
2256 struct Foo9124a(N...)
2257 {
2258 enum SIZE = N[0];
2259 private int _val;
2260
2261 public void opAssign (T) (T other)
2262 if (is(T unused == Foo9124a!(_N), _N...))
2263 {
2264 _val = other._val; // compile error
2265 this._val = other._val; // explicit this make it work
2266 }
2267
2268 public auto opUnary (string op) () if (op == "~") {
2269 Foo9124a!(SIZE) result = this;
2270 return result;
2271 }
2272 }
2273 void test9124a()
2274 {
2275 Foo9124a!(28) a;
2276 Foo9124a!(28) b = ~a;
2277 }
2278
2279 // --------
2280
2281 template Foo9124b(T, U, string OP)
2282 {
2283 enum N = T.SIZE;
2284 alias Foo9124b = Foo9124b!(false, true, N);
2285 }
2286 struct Foo9124b(bool S, bool L, N...)
2287 {
2288 enum SIZE = 5;
2289 long[1] _a = 0;
2290 void someFunction() const {
2291 auto data1 = _a; // Does not compile
2292 auto data2 = this._a; // <--- Compiles
2293 }
2294 auto opBinary(string op, T)(T) {
2295 Foo9124b!(typeof(this), T, op) test;
2296 }
2297 }
2298 void test9124b()
2299 {
2300 auto p = Foo9124b!(false, false, 5)();
2301 auto q = Foo9124b!(false, false, 5)();
2302 p|q;
2303 p&q;
2304 }
2305
2306 /**********************************/
2307 // 9143
2308
2309 struct Foo9143a(bool S, bool L)
2310 {
2311 auto noCall() {
2312 Foo9143a!(S, false) x1; // compiles if this line commented
2313 static if(S) Foo9143a!(true, false) x2;
2314 else Foo9143a!(false, false) x2;
2315 }
2316 this(T)(T other) // constructor
2317 if (is(T unused == Foo9143a!(P, Q), bool P, bool Q)) { }
2318 }
2319
2320 struct Foo9143b(bool L, size_t N)
2321 {
2322 void baaz0() {
2323 bar!(Foo9143b!(false, N))(); // line 7
2324 // -> move to before the baaz semantic
2325 }
2326 void baaz() {
2327 bar!(Foo9143b!(false, 2LU))(); // line 3
2328 bar!(Foo9143b!(true, 2LU))(); // line 4
2329 bar!(Foo9143b!(L, N))(); // line 5
2330 bar!(Foo9143b!(true, N))(); // line 6
2331 bar!(Foo9143b!(false, N))(); // line 7
2332 }
2333 void bar(T)()
2334 if (is(T unused == Foo9143b!(_L, _N), bool _L, size_t _N))
2335 {}
2336 }
2337
2338 void test9143()
2339 {
2340 Foo9143a!(false, true) k = Foo9143a!(false, false)();
2341
2342 auto p = Foo9143b!(true, 2LU)();
2343 }
2344
2345 /**********************************/
2346 // 9266
2347
2348 template Foo9266(T...)
2349 {
2350 T Foo9266;
2351 }
2352 struct Bar9266()
2353 {
2354 alias Foo9266!int f;
2355 }
2356 void test9266()
2357 {
2358 Bar9266!() a, b;
2359 }
2360
2361 /**********************************/
2362 // 9361
2363
2364 struct Unit9361(A)
2365 {
2366 void butPleaseDontUseMe()()
2367 if (is(unitType9361!((this)))) // !
2368 {}
2369
2370 }
2371 template isUnit9361(alias T) if ( is(T)) {}
2372 template isUnit9361(alias T) if (!is(T)) {}
2373
2374 template unitType9361(alias T) if (isUnit9361!T) {}
2375
2376 void test9361()
2377 {
2378 Unit9361!int u;
2379 static assert(!__traits(compiles, u.butPleaseDontUseMe())); // crashes
2380 }
2381
2382 /**********************************/
2383 // 9536
2384
2385 struct S9536
2386 {
2387 static A foo(A)(A a)
2388 {
2389 return a * 2;
2390 }
2391 int bar() const
2392 {
2393 return foo(42);
2394 }
2395 }
2396
2397 void test9536()
2398 {
2399 S9536 s;
2400 assert(s.bar() == 84);
2401 }
2402
2403 /**********************************/
2404 // 9578
2405
2406 template t9578(alias f) { void tf()() { f(); } }
2407
2408 void g9578a(alias f)() { f(); } // Error -> OK
2409 void g9578b(alias ti)() { ti.tf(); } // Error -> OK
2410
2411 void test9578()
2412 {
2413 int i = 0;
2414 int m() { return i; }
2415
2416 g9578a!(t9578!m.tf)();
2417 g9578b!(t9578!m)();
2418 }
2419
2420 /**********************************/
2421 // 9596
2422
2423 int foo9596a(K, V)(inout( V [K])) { return 1; }
2424 int foo9596a(K, V)(inout(shared(V) [K])) { return 2; }
2425
2426 int foo9596b(K, V)(inout( V [K])) { return 1; }
2427 int foo9596b(K, V)(inout( const(V) [K])) { return 3; }
2428
2429 int foo9596c(K, V)(inout(shared(V) [K])) { return 2; }
2430 int foo9596c(K, V)(inout( const(V) [K])) { return 3; }
2431
2432 int foo9596d(K, V)(inout( V [K])) { return 1; }
2433 int foo9596d(K, V)(inout(shared(V) [K])) { return 2; }
2434 int foo9596d(K, V)(inout( const(V) [K])) { return 3; }
2435
2436 int foo9596e(K, V)(inout(shared(V) [K])) { return 2; }
2437 int foo9596e(K, V)(inout( V [K])) { return 1; }
2438 int foo9596e(K, V)(inout( const(V) [K])) { return 3; }
2439
2440 void test9596()
2441 {
2442 shared(int)[int] aa;
2443 static assert(!__traits(compiles, foo9596a(aa)));
2444
2445 assert(foo9596b(aa) == 1);
2446 assert(foo9596c(aa) == 2);
2447
2448 static assert(!__traits(compiles, foo9596d(aa)));
2449 static assert(!__traits(compiles, foo9596e(aa)));
2450 }
2451
2452 /******************************************/
2453 // 9806
2454
2455 struct S9806a(alias x)
2456 {
2457 alias S9806a!0 N;
2458 }
2459 enum expr9806a = 0 * 0;
2460 alias S9806a!expr9806a T9806a;
2461
2462 // --------
2463
2464 struct S9806b(alias x)
2465 {
2466 template Next()
2467 {
2468 enum expr = x + 1;
2469 alias S9806b!expr Next;
2470 }
2471 }
2472 alias S9806b!1 One9806b;
2473 alias S9806b!0.Next!() OneAgain9806b;
2474
2475 // --------
2476
2477 struct S9806c(x...)
2478 {
2479 template Next()
2480 {
2481 enum expr = x[0] + 1;
2482 alias S9806c!expr Next;
2483 }
2484 }
2485 alias S9806c!1 One9806c;
2486 alias S9806c!0.Next!() OneAgain9806c;
2487
2488 /******************************************/
2489 // 9837
2490
2491 void test9837()
2492 {
2493 enum DA : int[] { a = [1,2,3] }
2494 DA da;
2495 int[] bda = da;
2496 static assert(is(DA : int[]));
2497 void fda1(int[] a) {}
2498 void fda2(T)(T[] a) {}
2499 fda1(da);
2500 fda2(da);
2501
2502 enum SA : int[3] { a = [1,2,3] }
2503 SA sa;
2504 int[3] bsa = sa;
2505 static assert(is(SA : int[3]));
2506 void fsa1(int[3] a) {}
2507 void fsa2(T)(T[3] a) {}
2508 void fsa3(size_t d)(int[d] a) {}
2509 void fsa4(T, size_t d)(T[d] a) {}
2510 fsa1(sa);
2511 fsa2(sa);
2512 fsa3(sa);
2513 fsa4(sa);
2514
2515 enum AA : int[int] { a = null }
2516 AA aa;
2517 int[int] baa = aa;
2518 static assert(is(AA : int[int]));
2519 void faa1(int[int] a) {}
2520 void faa2(V)(V[int] a) {}
2521 void faa3(K)(int[K] a) {}
2522 void faa4(K, V)(V[K] a) {}
2523 faa1(aa);
2524 faa2(aa);
2525 faa3(aa);
2526 faa4(aa);
2527 }
2528
2529 /******************************************/
2530 // 9874
2531
2532 bool foo9874() { return true; }
2533 void bar9874(T)(T) if (foo9874()) {} // OK
2534 void baz9874(T)(T) if (foo9874) {} // error
2535
2536 void test9874()
2537 {
2538 foo9874; // OK
2539 bar9874(0);
2540 baz9874(0);
2541 }
2542
2543 /******************************************/
2544
2545 void test9885()
2546 {
2547 void foo(int[1][]) {}
2548 void boo()(int[1][]){}
2549 struct X(T...) { static void xoo(T){} }
2550 struct Y(T...) { static void yoo()(T){} }
2551 struct Z(T...) { static void zoo(U...)(T, U){} }
2552
2553 struct V(T...) { static void voo()(T, ...){} }
2554 struct W(T...) { static void woo()(T...){} }
2555
2556 struct R(T...) { static void roo(U...)(int, U, T){} }
2557
2558 // OK
2559 foo([[10]]);
2560 boo([[10]]);
2561
2562 // OK
2563 X!(int[1][]).xoo([[10]]);
2564
2565 // NG!
2566 Y!().yoo();
2567 Y!(int).yoo(1);
2568 Y!(int, int[]).yoo(1, [10]);
2569 static assert(!__traits(compiles, Y!().yoo(1)));
2570 static assert(!__traits(compiles, Y!(int).yoo("a")));
2571 static assert(!__traits(compiles, Y!().yoo!(int)()));
2572
2573 // NG!
2574 Z!().zoo();
2575 Z!().zoo([1], [1:1]);
2576 Z!(int, string).zoo(1, "a");
2577 Z!(int, string).zoo(1, "a", [1], [1:1]);
2578 Z!().zoo!()();
2579 static assert(!__traits(compiles, Z!().zoo!()(1))); // (none) <- 1
2580 static assert(!__traits(compiles, Z!(int).zoo!()())); // int <- (none)
2581 static assert(!__traits(compiles, Z!(int).zoo!()(""))); // int <- ""
2582 static assert(!__traits(compiles, Z!().zoo!(int)())); // int <- (none)
2583 static assert(!__traits(compiles, Z!().zoo!(int)(""))); // int <- ""
2584
2585 V!().voo(1,2,3);
2586 V!(int).voo(1,2,3);
2587 V!(int, long).voo(1,2,3);
2588 static assert(!__traits(compiles, V!(int).voo())); // int <- (none)
2589 static assert(!__traits(compiles, V!(int, long).voo(1))); // long <- (none)
2590 static assert(!__traits(compiles, V!(int, string).voo(1,2,3))); // string <- 2
2591
2592 W!().woo();
2593 //W!().woo(1, 2, 3); // Access Violation
2594 { // this behavior is consistent with:
2595 //alias TL = TypeTuple!();
2596 //void foo(TL...) {}
2597 //foo(1, 2, 3); // Access Violation
2598 //pragma(msg, typeof(foo)); // void(...) -> D-style variadic function?
2599 }
2600 W!(int,int[]).woo(1,2,3);
2601 W!(int,int[2]).woo(1,2,3);
2602 static assert(!__traits(compiles, W!(int,int,int).woo(1,2,3))); // int... <- 2
2603 static assert(!__traits(compiles, W!(int,int).woo(1,2))); // int... <- 2
2604 static assert(!__traits(compiles, W!(int,int[2]).woo(1,2))); // int[2]... <- 2
2605
2606 R!().roo(1, "", []);
2607 R!(int).roo(1, "", [], 1);
2608 R!(int, string).roo(1, "", [], 1, "");
2609 R!(int, string).roo(1, 2, "");
2610 static assert(!__traits(compiles, R!(int).roo(1, "", []))); // int <- []
2611 static assert(!__traits(compiles, R!(int, int).roo(1, "", []))); // int <- []
2612 static assert(!__traits(compiles, R!(int, string).roo(1, 2, 3))); // string <- 3
2613
2614 // test case
2615 struct Tuple(T...) { this()(T values) {} }
2616 alias T = Tuple!(int[1][]);
2617 auto t = T([[10]]);
2618 }
2619
2620 /******************************************/
2621 // 9971
2622
2623 void goo9971()()
2624 {
2625 auto g = &goo9971;
2626 }
2627
2628 struct S9971
2629 {
2630 void goo()()
2631 {
2632 auto g = &goo;
2633 static assert(is(typeof(g) == delegate));
2634 }
2635 }
2636
2637 void test9971()
2638 {
2639 goo9971!()();
2640
2641 S9971.init.goo!()();
2642 }
2643
2644 /******************************************/
2645 // 9977
2646
2647 void test9977()
2648 {
2649 struct S1(T) { T value; }
2650 auto func1(T)(T value) { return value; }
2651 static assert(is(S1!int == struct));
2652 assert(func1(10) == 10);
2653
2654 template S2(T) { struct S2 { T value; } }
2655 template func2(T) { auto func2(T value) { return value; } }
2656 static assert(is(S2!int == struct));
2657 assert(func2(10) == 10);
2658
2659 template X(T) { alias X = T[3]; }
2660 static assert(is(X!int == int[3]));
2661
2662 int a;
2663 template Y(T) { alias Y = T[typeof(a)]; }
2664 static assert(is(Y!double == double[int]));
2665
2666 int v = 10;
2667 template Z() { alias Z = v; }
2668 assert(v == 10);
2669 Z!() = 20;
2670 assert(v == 20);
2671 }
2672
2673 /******************************************/
2674
2675 enum T8848a(int[] a) = a;
2676 enum T8848b(int[int] b) = b;
2677 enum T8848c(void* c) = c;
2678
2679 static assert(T8848a!([1,2,3]) == [1,2,3]);
2680 static assert(T8848b!([1:2,3:4]) == [1:2,3:4]);
2681 static assert(T8848c!(null) == null);
2682
2683 /******************************************/
2684 // 9990
2685
2686 auto initS9990() { return "hi"; }
2687
2688 class C9990(alias init) {}
2689
2690 alias SC9990 = C9990!(initS9990);
2691
2692 /******************************************/
2693 // 10067
2694
2695 struct assumeSize10067(alias F) {}
2696
2697 template useItemAt10067(size_t idx, T)
2698 {
2699 void impl(){ }
2700
2701 alias useItemAt10067 = assumeSize10067!(impl);
2702 }
2703
2704 useItemAt10067!(0, char) mapS10067;
2705
2706 /******************************************/
2707 // 4072
2708
2709 void bug4072(T)(T x)
2710 if (is(typeof(bug4072(x))))
2711 {}
2712
2713 static assert(!is(typeof(bug4072(7))));
2714
2715 /******************************************/
2716 // 10074
2717
2718 template foo10074(F)
2719 {
2720 enum foo10074 = false;
2721 }
2722 bool foo10074(F)(F f)
2723 if (foo10074!F)
2724 {
2725 return false;
2726 }
2727
2728 static assert(!is(typeof(foo10074(1))));
2729
2730 /******************************************/
2731 // 10083
2732
2733 // [a-c] IFTI can find syntactic eponymous member
2734 template foo10083a(T)
2735 {
2736 int foo10083a(double) { return 1; }
2737 int foo10083a(T) { return 2; }
2738 }
2739 template foo10083b(T)
2740 {
2741 int foo10083b(T) { return 1; }
2742 int foo10083b(T, T) { return 2; }
2743 }
2744 template foo10083c1(T)
2745 {
2746 int foo10083c1(T) { return 1; }
2747 static if (true) { int x; }
2748 }
2749 template foo10083c2(T)
2750 {
2751 int foo10083c2(T) { return 1; }
2752 static if (true) { int x; } else { int y; }
2753 }
2754
2755 // [d-f] IFTI cannot find syntactic eponymous member
2756 template foo10083d1(T)
2757 {
2758 static if (true)
2759 {
2760 int foo10083d1(T) { return 1; }
2761 }
2762 else
2763 {
2764 }
2765 }
2766 template foo10083d2(T)
2767 {
2768 static if (true)
2769 {
2770 }
2771 else
2772 {
2773 int foo10083d2(T) { return 1; }
2774 }
2775 }
2776 template foo10083e(T)
2777 {
2778 static if (true)
2779 {
2780 int foo10083e(double arg) { return 1; }
2781 }
2782 int foo10083e(T arg) { return 2; }
2783 }
2784 template foo10083f(T)
2785 {
2786 static if (true)
2787 {
2788 int foo10083f(T) { return 1; }
2789 }
2790 else
2791 {
2792 int foo10083f(T) { return 2; }
2793 }
2794 }
2795
2796 void test10083()
2797 {
2798 assert(foo10083a(1) == 2);
2799 assert(foo10083a!int(1) == 2);
2800 assert(foo10083a!int(1.0) == 1);
2801 static assert(!__traits(compiles, foo10083a!double(1)));
2802 static assert(!__traits(compiles, foo10083a!double(1.0)));
2803 static assert(!__traits(compiles, foo10083a!real(1)));
2804 assert(foo10083a!real(1.0) == 1);
2805 assert(foo10083a!real(1.0L) == 2);
2806
2807 assert(foo10083b(2) == 1);
2808 assert(foo10083b(3, 4) == 2);
2809 static assert(!__traits(compiles, foo10083b(2, "")));
2810
2811 assert(foo10083c1(1) == 1);
2812 assert(foo10083c2(1) == 1);
2813
2814 static assert(!__traits(compiles, foo10083d1(2)));
2815 static assert(!__traits(compiles, foo10083d2(2)));
2816 static assert(!__traits(compiles, foo10083e(3)));
2817 static assert(!__traits(compiles, foo10083f(3)));
2818 }
2819
2820 /******************************************/
2821 // 10134
2822
2823 template ReturnType10134(alias func)
2824 {
2825 static if (is(typeof(func) R == return))
2826 alias R ReturnType10134;
2827 else
2828 static assert(0);
2829 }
2830
2831 struct Result10134(T) {}
2832
2833 template getResultType10134(alias func)
2834 {
2835 static if(is(ReturnType10134!(func.exec) _ == Result10134!(T), T))
2836 {
2837 alias getResultType10134 = T;
2838 }
2839 }
2840
2841 template f10134(alias func)
2842 {
2843 Result10134!(getResultType10134!(func)) exec(int i)
2844 {
2845 return typeof(return)();
2846 }
2847 }
2848
2849 template a10134()
2850 {
2851 Result10134!(double) exec(int i)
2852 {
2853 return b10134!().exec(i);
2854 }
2855 }
2856
2857 template b10134()
2858 {
2859 Result10134!(double) exec(int i)
2860 {
2861 return f10134!(a10134!()).exec(i);
2862 }
2863 }
2864
2865 pragma(msg, getResultType10134!(a10134!()));
2866
2867 /******************************************/
2868 // 10313
2869
2870 void test10313()
2871 {
2872 struct Nullable(T)
2873 {
2874 this()(inout T value) inout {}
2875 }
2876
2877 struct S { S[] array; }
2878 S s;
2879 auto ns = Nullable!S(s);
2880
2881 class C { C[] array; }
2882 C c;
2883 auto nc = Nullable!C(c);
2884 }
2885
2886 /******************************************/
2887 // 10498
2888
2889 template triggerIssue10498a()
2890 {
2891 enum triggerIssue10498a = __traits(compiles, { T10498a; });
2892 }
2893
2894 template PackedGenericTuple10498a(Args...)
2895 {
2896 alias Args Tuple;
2897 enum e = triggerIssue10498a!();
2898 }
2899
2900 struct S10498a { }
2901
2902 template T10498a()
2903 {
2904 alias PackedGenericTuple10498a!S10498a T10498a;
2905 }
2906
2907 void test10498a()
2908 {
2909 alias T10498a!() t;
2910 static assert(is(t.Tuple[0])); // Fails -> OK
2911 }
2912
2913 // --------
2914
2915 template triggerIssue10498b(A...)
2916 {
2917 enum triggerIssue10498b = __traits(compiles, { auto a = A[0]; });
2918 }
2919
2920 template PackedGenericTuple10498b(Args...)
2921 {
2922 alias Args Tuple;
2923 enum e = triggerIssue10498b!Args;
2924 }
2925
2926 template T10498b()
2927 {
2928 struct S {} // The fact `S` is in `T` causes the problem
2929 alias PackedGenericTuple10498b!S T10498b;
2930 }
2931
2932 void test10498b()
2933 {
2934 alias T10498b!() t;
2935 static assert(is(t.Tuple[0]));
2936 }
2937
2938 /******************************************/
2939 // 10537
2940
2941 struct Iota10537
2942 {
2943 int s,e,i;
2944 mixin Yield10537!q{ ; };
2945 }
2946
2947 auto skipStrings10537(T)(T source)
2948 {
2949 return "";
2950 }
2951
2952 mixin template Yield10537(dstring code)
2953 {
2954 alias X = typeof({ enum x = rewriteCode10537(code); }());
2955 }
2956
2957 dstring rewriteCode10537(dstring code)
2958 {
2959 skipStrings10537(code); // IFTI causes forward reference
2960 return "";
2961 }
2962
2963 /******************************************/
2964 // 10558
2965
2966 template Template10558() {}
2967
2968 struct Struct10558(alias T){}
2969
2970 alias bar10558 = foo10558!(Template10558!());
2971
2972 template foo10558(alias T)
2973 {
2974 alias foobar = Struct10558!T;
2975
2976 void fun()
2977 {
2978 alias a = foo10558!T;
2979 }
2980 }
2981
2982 /******************************************/
2983 // 10592
2984
2985 void test10592()
2986 {
2987 struct A(E)
2988 {
2989 int put()(const(E)[] data)
2990 {
2991 return 1;
2992 }
2993
2994 int put()(const(dchar)[] data) if (!is(E == dchar))
2995 {
2996 return 2;
2997 }
2998
2999 int put(C)(const(C)[] data) if (!is(C == dchar) && !is(E == C))
3000 {
3001 return 3;
3002 }
3003 }
3004
3005 A!char x;
3006 assert(x.put("abcde"c) == 1); // OK: hit 1
3007 assert(x.put("abcde"w) == 3); // NG: this should hit 3
3008 assert(x.put("abcde"d) == 2); // OK: hit 2
3009 }
3010
3011 /******************************************/
3012 // 11242
3013
3014 inout(T[]) fromString11242(T)(inout(char[]) s, T[] dst)
3015 {
3016 return s;
3017 }
3018
3019 void test11242()
3020 {
3021 char[] a;
3022 fromString11242(a, a);
3023 }
3024
3025 /******************************************/
3026 // 10811
3027
3028 void foo10811a(R1, R2)(R1, R2) {}
3029 template foo10811a(alias pred) { void foo10811a(R1, R2)(R1, R2) {} }
3030
3031 template foo10811b(alias pred) { void foo10811b(R1, R2)(R1, R2) {} }
3032 void foo10811b(R1, R2)(R1, R2) {}
3033
3034 void test10811()
3035 {
3036 foo10811a(1, 2);
3037 foo10811a!(a => a)(1, 2);
3038
3039 foo10811b(1, 2);
3040 foo10811b!(a => a)(1, 2);
3041 }
3042
3043 /******************************************/
3044 // 10969
3045
3046 template A10969(T, U...) { alias A10969 = T; }
3047 void foo10969(T, U...)(A10969!(T, U) a) {}
3048
3049 template B10969(T, U) { alias B10969 = T; }
3050 void bar10969(T, U...)(B10969!(T, U[0]) a) {}
3051
3052 void test10969()
3053 {
3054 foo10969!(int, float)(3);
3055 bar10969!(int, float)(3);
3056 }
3057
3058 /******************************************/
3059 // 11271
3060
3061 struct SmartPtr11271(T)
3062 {
3063 ~this() {}
3064 void opAssign(U)(auto ref U rh) {}
3065 }
3066
3067 void test11271()
3068 {
3069 SmartPtr11271!Object a;
3070 a = SmartPtr11271!Object();
3071 }
3072
3073 /******************************************/
3074 // 11533
3075
3076 version (none)
3077 {
3078 struct S11533
3079 {
3080 void put(alias fun)() { fun!int(); }
3081 }
3082 void test11533a()
3083 {
3084 static void foo(T)() {}
3085 S11533 s;
3086 s.put!foo();
3087 }
3088
3089 void test11533b()
3090 {
3091 static void bar(alias fun)() { fun(); }
3092 void nested() {}
3093 bar!nested();
3094 }
3095
3096 void test11533c()
3097 {
3098 static struct Foo(alias fun)
3099 {
3100 auto call() { return fun(); }
3101 }
3102 int var = 1;
3103 auto getVar() { return var; }
3104 Foo!getVar foo;
3105 assert(foo.call() == var);
3106 var += 1;
3107 assert(foo.call() == var);
3108 }
3109
3110 void test11533()
3111 {
3112 test11533a();
3113 test11533b();
3114 test11533c();
3115 }
3116 }
3117 else
3118 {
3119 void test11533()
3120 {
3121 }
3122 }
3123
3124 /******************************************/
3125 // 11553
3126
3127 struct Pack11553(T ...)
3128 {
3129 alias Unpack = T;
3130 enum length = T.length;
3131 }
3132
3133 template isPack11553(TList ...)
3134 {
3135 static if (TList.length == 1 && is(Pack11553!(TList[0].Unpack) == TList[0]))
3136 {
3137 enum isPack11553 = true;
3138 }
3139 else
3140 {
3141 enum isPack11553 = false;
3142 }
3143 }
3144
3145 template PartialApply11553(alias T, uint argLoc, Arg ...)
3146 if (Arg.length == 1)
3147 {
3148 template PartialApply11553(L ...)
3149 {
3150 alias PartialApply11553 = T!(L[0 .. argLoc], Arg, L[argLoc .. $]);
3151 }
3152 }
3153
3154 template _hasLength11553(size_t len, T)
3155 {
3156 static if (T.length == len)
3157 {
3158 enum _hasLength11553 = true;
3159 }
3160 else
3161 {
3162 enum _hasLength11553 = false;
3163 }
3164 }
3165
3166 alias _hasLength11553(size_t len) = PartialApply11553!(._hasLength11553, 0, len);
3167
3168
3169 alias hl11553 = _hasLength11553!1;
3170
3171 // this segfaults
3172 static if (!isPack11553!hl11553) { pragma(msg, "All good 1"); }
3173
3174 // these are fine
3175 static if ( hl11553!(Pack11553!(5))) { pragma(msg, "All good 2"); }
3176
3177 static if (!hl11553!(Pack11553!( ))) { pragma(msg, "All good 3"); }
3178
3179 /******************************************/
3180 // 11818
3181
3182 enum E11818 { e0, e1 }
3183
3184 struct SortedRange11818
3185 {
3186 void fun(E11818 e = true ? E11818.e0 : E11818.e1)()
3187 {
3188 }
3189 }
3190
3191 void test11818()
3192 {
3193 SortedRange11818 s;
3194 s.fun();
3195 }
3196
3197 /******************************************/
3198 // 11843
3199
3200 void test11843()
3201 {
3202 struct Foo
3203 {
3204 int x[string];
3205 }
3206
3207 struct Bar(alias foo) {}
3208
3209 enum bar1 = Bar!(Foo(["a": 1]))();
3210 enum bar2 = Bar!(Foo(["a": 1]))();
3211 static assert(is(typeof(bar1) == typeof(bar2)));
3212
3213 enum foo1 = Foo(["a": 1]);
3214 enum foo2 = Foo(["b": -1]);
3215 static assert(!__traits(isSame, foo1, foo2));
3216 enum bar3 = Bar!foo1();
3217 enum bar4 = Bar!foo2();
3218 static assert(!is(typeof(bar3) == typeof(bar4)));
3219 }
3220
3221 /******************************************/
3222 // 11872
3223
3224 class Foo11872
3225 {
3226 auto test(int v)() {}
3227 auto test(int v)(string) {}
3228
3229 template Bar(T)
3230 {
3231 void test(T) {}
3232 }
3233 }
3234
3235 void test11872()
3236 {
3237 auto foo = new Foo11872();
3238
3239 with (foo)
3240 {
3241 // ScopeExp(ti) -> DotTemplateInstanceExp(wthis, ti)
3242 foo.test!2(); // works
3243 test!2(); // works <- fails
3244 test!2; // works <- fails
3245
3246 // ScopeExp(ti) -> DotTemplateInstanceExp(wthis, ti) -> DotExp(wthis, ScopeExp)
3247 foo.Bar!int.test(1); // works
3248 Bar!int.test(1); // works <- fails
3249 }
3250 }
3251
3252 /******************************************/
3253 // 12042
3254
3255 struct S12042
3256 {
3257 int[] t;
3258
3259 void m()()
3260 {
3261 t = null; // CTFE error -> OK
3262 }
3263 }
3264
3265 int test12042()
3266 {
3267 S12042 s;
3268
3269 with (s)
3270 m!()();
3271
3272 return 1;
3273 }
3274
3275 static assert(test12042());
3276
3277 /******************************************/
3278 // 12077
3279
3280 struct S12077(A) {}
3281
3282 alias T12077(alias T : Base!Args, alias Base, Args...) = Base;
3283 static assert(__traits(isSame, T12077!(S12077!int), S12077));
3284
3285 alias U12077(alias T : Base!Args, alias Base, Args...) = Base;
3286 alias U12077( T : Base!Args, alias Base, Args...) = Base;
3287 static assert(__traits(isSame, U12077!(S12077!int), S12077));
3288
3289 /******************************************/
3290 // 12262
3291
3292 template Inst12262(T) { int x; }
3293
3294 enum fqnSym12262(alias a) = 1;
3295 enum fqnSym12262(alias a : B!A, alias B, A...) = 2;
3296
3297 static assert(fqnSym12262!(Inst12262!(Object)) == 2);
3298 static assert(fqnSym12262!(Inst12262!(Object).x) == 1);
3299
3300 /******************************************/
3301 // 12264
3302
3303 struct S12264(A) {}
3304
3305 template AX12264(alias A1) { enum AX12264 = 1; }
3306 template AX12264(alias A2 : B!A, alias B, A...) { enum AX12264 = 2; }
3307 template AY12264(alias A1) { enum AY12264 = 1; }
3308 template AY12264(alias A2 : B!int, alias B) { enum AY12264 = 2; }
3309 template AZ12264(alias A1) { enum AZ12264 = 1; }
3310 template AZ12264(alias A2 : S12264!T, T) { enum AZ12264 = 2; }
3311 static assert(AX12264!(S12264!int) == 2);
3312 static assert(AY12264!(S12264!int) == 2);
3313 static assert(AZ12264!(S12264!int) == 2);
3314
3315 template TX12264(T1) { enum TX12264 = 1; }
3316 template TX12264(T2 : B!A, alias B, A...) { enum TX12264 = 2; }
3317 template TY12264(T1) { enum TY12264 = 1; }
3318 template TY12264(T2 : B!int, alias B) { enum TY12264 = 2; }
3319 template TZ12264(T1) { enum TZ12264 = 1; }
3320 template TZ12264(T2 : S12264!T, T) { enum TZ12264 = 2; }
3321 static assert(TX12264!(S12264!int) == 2);
3322 static assert(TY12264!(S12264!int) == 2);
3323 static assert(TZ12264!(S12264!int) == 2);
3324
3325 /******************************************/
3326 // 12122
3327
3328 enum N12122 = 1;
3329
3330 void foo12122(T)(T[N12122]) if(is(T == int)) {}
3331
3332 void test12122()
3333 {
3334 int[N12122] data;
3335 foo12122(data);
3336 }
3337
3338 /******************************************/
3339 // 12186
3340
3341 template map_front12186(fun...)
3342 {
3343 auto map_front12186(Range)(Range r)
3344 {
3345 return fun[0](r[0]);
3346 }
3347 }
3348
3349 void test12186()
3350 {
3351 immutable int[][] mat;
3352
3353 mat.map_front12186!((in r) => 0); // OK
3354 mat.map_front12186!((const r) => 0); // OK
3355 mat.map_front12186!((immutable int[] r) => 0); // OK
3356 mat.map_front12186!((immutable r) => 0); // OK <- Error
3357 }
3358
3359 /******************************************/
3360 // 12207
3361
3362 void test12207()
3363 {
3364 static struct S
3365 {
3366 static void f(T)(T) {}
3367 }
3368
3369 immutable S s;
3370
3371 s.f(1);
3372 }
3373
3374 /******************************************/
3375 // 12263
3376
3377 template A12263(alias a) { int x; }
3378 template B12263(alias a) { int x; }
3379
3380 template fqnSym12263(alias T : B12263!A, alias B12263, A...)
3381 {
3382 enum fqnSym12263 = true;
3383 }
3384
3385 static assert(fqnSym12263!(A12263!(Object)));
3386 static assert(fqnSym12263!(B12263!(Object)));
3387
3388 /******************************************/
3389 // 12290
3390
3391 void test12290()
3392 {
3393 short[] arrS;
3394 float[] arrF;
3395 double[] arrD;
3396 real[] arrR;
3397 string cstr;
3398 wstring wstr;
3399 dstring dstr;
3400 short[short] aa;
3401
3402 auto func1a(E)(E[], E) { return E.init; }
3403 auto func1b(E)(E, E[]) { return E.init; }
3404
3405 static assert(is(typeof(func1a(arrS, 1)) == short));
3406 static assert(is(typeof(func1b(1, arrS)) == short));
3407 static assert(is(typeof(func1a(arrF, 1.0)) == float));
3408 static assert(is(typeof(func1b(1.0, arrF)) == float));
3409 static assert(is(typeof(func1a(arrD, 1.0L)) == double));
3410 static assert(is(typeof(func1b(1.0L, arrD)) == double));
3411 static assert(is(typeof(func1a(arrR, 1)) == real));
3412 static assert(is(typeof(func1b(1, arrR)) == real));
3413 static assert(is(typeof(func1a("str" , 'a')) == immutable char));
3414 static assert(is(typeof(func1b('a', "str" )) == immutable char));
3415 static assert(is(typeof(func1a("str"c, 'a')) == immutable char));
3416 static assert(is(typeof(func1b('a', "str"c)) == immutable char));
3417 static assert(is(typeof(func1a("str"w, 'a')) == immutable wchar));
3418 static assert(is(typeof(func1b('a', "str"w)) == immutable wchar));
3419 static assert(is(typeof(func1a("str"d, 'a')) == immutable dchar));
3420 static assert(is(typeof(func1b('a', "str"d)) == immutable dchar));
3421 static assert(is(typeof(func1a([1,2,3], 1L)) == long));
3422 static assert(is(typeof(func1b(1L, [1,2,3])) == long));
3423 static assert(is(typeof(func1a([1,2,3], 1.5)) == double));
3424 static assert(is(typeof(func1b(1.5, [1,2,3])) == double));
3425 static assert(is(typeof(func1a(["a","b"], "s"c)) == string));
3426 static assert(is(typeof(func1b("s"c, ["a","b"])) == string));
3427 static assert(is(typeof(func1a(["a","b"], "s"w)) == wstring));
3428 static assert(is(typeof(func1b("s"w, ["a","b"])) == wstring));
3429 static assert(is(typeof(func1a(["a","b"], "s"d)) == dstring));
3430 static assert(is(typeof(func1b("s"d, ["a","b"])) == dstring));
3431
3432 auto func2a(K, V)(V[K], K, V) { return V[K].init; }
3433 auto func2b(K, V)(V, K, V[K]) { return V[K].init; }
3434
3435 static assert(is(typeof(func2a(aa, 1, 1)) == short[short]));
3436 static assert(is(typeof(func2b(1, 1, aa)) == short[short]));
3437 static assert(is(typeof(func2a([1:10,2:20,3:30], 1L, 10L)) == long[long]));
3438 static assert(is(typeof(func2b(1L, 10L, [1:20,2:20,3:30])) == long[long]));
3439
3440 auto func3a(T)(T, T) { return T.init; }
3441 auto func3b(T)(T, T) { return T.init; }
3442
3443 static assert(is(typeof(func3a(arrS, null)) == short[]));
3444 static assert(is(typeof(func3b(null, arrS)) == short[]));
3445 static assert(is(typeof(func3a(arrR, null)) == real[]));
3446 static assert(is(typeof(func3b(null, arrR)) == real[]));
3447 static assert(is(typeof(func3a(cstr, "str")) == string));
3448 static assert(is(typeof(func3b("str", cstr)) == string));
3449 static assert(is(typeof(func3a(wstr, "str")) == wstring));
3450 static assert(is(typeof(func3b("str", wstr)) == wstring));
3451 static assert(is(typeof(func3a(dstr, "str")) == dstring));
3452 static assert(is(typeof(func3b("str", dstr)) == dstring));
3453 static assert(is(typeof(func3a("str1" , "str2"c)) == string));
3454 static assert(is(typeof(func3b("str1"c, "str2" )) == string));
3455 static assert(is(typeof(func3a("str1" , "str2"w)) == wstring));
3456 static assert(is(typeof(func3b("str1"w, "str2" )) == wstring));
3457 static assert(is(typeof(func3a("str1" , "str2"d)) == dstring));
3458 static assert(is(typeof(func3b("str1"d, "str2" )) == dstring));
3459
3460 inout(V) get(K, V)(inout(V[K]) aa, K key, lazy V defaultValue) { return V.init; }
3461
3462 short[short] hash12220;
3463 short res12220 = get(hash12220, 1, 1);
3464
3465 short[short] hash12221;
3466 enum Key12221 : short { a }
3467 get(hash12221, Key12221.a, Key12221.a);
3468
3469 int[][string] mapping13026;
3470 int[] v = get(mapping13026, "test", []);
3471 }
3472
3473 /******************************************/
3474 // 12292
3475
3476 void test12292()
3477 {
3478 void fun(T : string)(T data) {}
3479
3480 ubyte[3] sa;
3481 static assert(!__traits(compiles, fun(sa)));
3482 static assert(!__traits(compiles, { alias f = fun!(ubyte[3]); }));
3483 }
3484
3485 /******************************************/
3486 // 12376
3487
3488 static auto encode12376(size_t sz)(dchar ch) if (sz > 1)
3489 {
3490 undefined;
3491 }
3492
3493 void test12376()
3494 {
3495 enum x = __traits(compiles, encode12376!2(x));
3496 }
3497
3498 /******************************************/
3499 // 12447
3500
3501 enum test12447(string str) = str; // [1]
3502 string test12447(T...)(T args) if (T.length) { return args[0]; } // [2]
3503
3504 // With [1]: The template parameter str cannot be be deduced -> no match
3505 // With [2]: T is deduced to a type tuple (string), then match to the function call.
3506 static assert(test12447("foo") == "foo");
3507
3508 // With [1]: template parameter str is deduced to "bar", then match.
3509 // With [2]: T is deduced to an expression tuple ("bar"), but it will make invalid the function signature (T args).
3510 // The failure should be masked silently and prefer the 1st version.
3511 static assert(test12447!("bar") == "bar");
3512
3513 /******************************************/
3514 // 12651
3515
3516 alias TemplateArgsOf12651(alias T : Base!Args, alias Base, Args...) = Args;
3517
3518 struct S12651(T) { }
3519
3520 static assert(!__traits(compiles, TemplateArgsOf12651!(S12651!int, S, float)));
3521
3522 /******************************************/
3523 // 12719
3524
3525 struct A12719
3526 {
3527 B12719!int b();
3528 }
3529
3530 struct B12719(T)
3531 {
3532 A12719 a;
3533 void m()
3534 {
3535 auto v = B12719!T.init;
3536 }
3537 }
3538
3539 // --------
3540
3541 enum canDoIt12719(R) = is(typeof(W12719!R));
3542
3543 struct W12719(R)
3544 {
3545 R r;
3546 static if (canDoIt12719!R) {}
3547 }
3548
3549 W12719!int a12719;
3550
3551 /******************************************/
3552 // 12746
3553
3554 template foo12746()
3555 {
3556 void bar()
3557 {
3558 static assert(!__traits(compiles, bar(1)));
3559 }
3560 alias foo12746 = bar;
3561 }
3562
3563 void foo12746(int)
3564 {
3565 assert(0);
3566 }
3567
3568 void test12746()
3569 {
3570 foo12746(); // instantiate
3571 }
3572
3573 /******************************************/
3574 // 12748
3575
3576 void foo12748(S, C : typeof(S.init[0]))(S s, C c)
3577 {
3578 }
3579
3580 void test12748()
3581 {
3582 foo12748("abc", 'd');
3583 }
3584
3585 /******************************************/
3586 // 9708
3587
3588 struct S9708
3589 {
3590 void f()(inout(Object)) inout {}
3591 }
3592
3593 void test9708()
3594 {
3595 S9708 s;
3596 s.f(new Object);
3597 }
3598
3599 /******************************************/
3600 // 12880
3601
3602 void f12880(T)(in T value) { static assert(is(T == string)); }
3603 void test12880() { f12880(string.init); }
3604
3605 /******************************************/
3606 // 13087
3607
3608 struct Vec13087
3609 {
3610 int x;
3611 void m() { auto n = component13087!(this, 'x'); }
3612 void c() const { auto n = component13087!(this, 'x'); }
3613 void w() inout { auto n = component13087!(this, 'x'); }
3614 void wc() inout const { auto n = component13087!(this, 'x'); }
3615 void s() shared { auto n = component13087!(this, 'x'); }
3616 void sc() shared const { auto n = component13087!(this, 'x'); }
3617 void sw() shared inout { auto n = component13087!(this, 'x'); }
3618 void swc() shared inout const { auto n = component13087!(this, 'x'); }
3619 void i() immutable { auto n = component13087!(this, 'x'); }
3620 }
3621
3622 template component13087(alias vec, char c)
3623 {
3624 alias component13087 = vec.x;
3625 }
3626
3627 /******************************************/
3628 // 13127
3629
3630 /+void test13127(inout int = 0)
3631 {
3632 int [] ma1;
3633 const(int)[] ca1;
3634 const(int[]) ca2;
3635 inout( int)[] wma1;
3636 inout( int[]) wma2;
3637 inout(const int)[] wca1;
3638 inout(const int[]) wca2;
3639 immutable(int)[] ia1;
3640 immutable(int[]) ia2;
3641 shared( int)[] sma1;
3642 shared( int[]) sma2;
3643 shared( const int)[] sca1;
3644 shared( const int[]) sca2;
3645 shared(inout int)[] swma1;
3646 shared(inout int[]) swma2;
3647 shared(inout const int)[] swca1;
3648 shared(inout const int[]) swca2;
3649
3650 /* In all cases, U should be deduced to top-unqualified type.
3651 */
3652
3653 /* Parameter is (shared) mutable
3654 */
3655 U f_m(U)( U) { return null; }
3656 U fsm(U)(shared U) { return null; }
3657 // 9 * 2 - 1
3658 static assert(is(typeof(f_m( ma1)) == int []));
3659 static assert(is(typeof(f_m( ca1)) == const(int)[]));
3660 static assert(is(typeof(f_m( ca2)) == const(int)[]));
3661 static assert(is(typeof(f_m( wma1)) == inout( int)[]));
3662 static assert(is(typeof(f_m( wma2)) == inout( int)[]));
3663 static assert(is(typeof(f_m( wca1)) == inout(const int)[]));
3664 static assert(is(typeof(f_m( wca2)) == inout(const int)[]));
3665 static assert(is(typeof(f_m( ia1)) == immutable(int)[]));
3666 static assert(is(typeof(f_m( ia2)) == immutable(int)[]));
3667 static assert(is(typeof(f_m( sma1)) == shared( int)[]));
3668 static assert(is(typeof(f_m( sma2)) == shared( int)[])); // <- shared(int[])
3669 static assert(is(typeof(f_m( sca1)) == shared( const int)[]));
3670 static assert(is(typeof(f_m( sca2)) == shared( const int)[])); // <- shared(const(int)[])
3671 static assert(is(typeof(f_m(swma1)) == shared(inout int)[]));
3672 static assert(is(typeof(f_m(swma2)) == shared(inout int)[])); // <- shared(inout(int[]))
3673 static assert(is(typeof(f_m(swca1)) == shared(inout const int)[]));
3674 static assert(is(typeof(f_m(swca2)) == shared(inout const int)[])); // <- shared(inout(const(int))[])
3675 // 9 * 2 - 1
3676 static assert(is(typeof(fsm( ma1))) == false);
3677 static assert(is(typeof(fsm( ca1))) == false);
3678 static assert(is(typeof(fsm( ca2))) == false);
3679 static assert(is(typeof(fsm( wma1))) == false);
3680 static assert(is(typeof(fsm( wma2))) == false);
3681 static assert(is(typeof(fsm( wca1))) == false);
3682 static assert(is(typeof(fsm( wca2))) == false);
3683 static assert(is(typeof(fsm( ia1))) == false);
3684 static assert(is(typeof(fsm( ia2))) == false);
3685 static assert(is(typeof(fsm( sma1)) == shared( int)[])); // <- NG
3686 static assert(is(typeof(fsm( sma2)) == shared( int)[]));
3687 static assert(is(typeof(fsm( sca1)) == shared( const int)[])); // <- NG
3688 static assert(is(typeof(fsm( sca2)) == shared( const int)[]));
3689 static assert(is(typeof(fsm(swma1)) == shared(inout int)[])); // <- NG
3690 static assert(is(typeof(fsm(swma2)) == shared(inout int)[]));
3691 static assert(is(typeof(fsm(swca1)) == shared(inout const int)[])); // <- NG
3692 static assert(is(typeof(fsm(swca2)) == shared(inout const int)[]));
3693
3694 /* Parameter is (shared) const
3695 */
3696 U f_c(U)( const U) { return null; }
3697 U fsc(U)(shared const U) { return null; }
3698 // 9 * 2 - 1
3699 static assert(is(typeof(f_c( ma1)) == int []));
3700 static assert(is(typeof(f_c( ca1)) == const(int)[]));
3701 static assert(is(typeof(f_c( ca2)) == const(int)[]));
3702 static assert(is(typeof(f_c( wma1)) == inout( int)[]));
3703 static assert(is(typeof(f_c( wma2)) == inout( int)[]));
3704 static assert(is(typeof(f_c( wca1)) == inout(const int)[]));
3705 static assert(is(typeof(f_c( wca2)) == inout(const int)[]));
3706 static assert(is(typeof(f_c( ia1)) == immutable(int)[]));
3707 static assert(is(typeof(f_c( ia2)) == immutable(int)[]));
3708 static assert(is(typeof(f_c( sma1)) == shared( int)[]));
3709 static assert(is(typeof(f_c( sma2)) == shared( int)[])); // <- shared(int[])
3710 static assert(is(typeof(f_c( sca1)) == shared( const int)[]));
3711 static assert(is(typeof(f_c( sca2)) == shared( const int)[])); // <- shared(const(int)[])
3712 static assert(is(typeof(f_c(swma1)) == shared(inout int)[]));
3713 static assert(is(typeof(f_c(swma2)) == shared(inout int)[])); // shared(inout(int)[])
3714 static assert(is(typeof(f_c(swca1)) == shared(inout const int)[]));
3715 static assert(is(typeof(f_c(swca2)) == shared(inout const int)[])); // shared(inout(const(int))[])
3716 // 9 * 2 - 1
3717 static assert(is(typeof(fsc( ma1))) == false);
3718 static assert(is(typeof(fsc( ca1))) == false);
3719 static assert(is(typeof(fsc( ca2))) == false);
3720 static assert(is(typeof(fsc( wma1))) == false);
3721 static assert(is(typeof(fsc( wma2))) == false);
3722 static assert(is(typeof(fsc( wca1))) == false);
3723 static assert(is(typeof(fsc( wca2))) == false);
3724 static assert(is(typeof(fsc( ia1)) == immutable(int)[])); // <- NG
3725 static assert(is(typeof(fsc( ia2)) == immutable(int)[])); // <- NG
3726 static assert(is(typeof(fsc( sma1)) == shared( int)[])); // <- NG
3727 static assert(is(typeof(fsc( sma2)) == shared( int)[]));
3728 static assert(is(typeof(fsc( sca1)) == shared( const int)[])); // <- NG
3729 static assert(is(typeof(fsc( sca2)) == shared( const int)[]));
3730 static assert(is(typeof(fsc(swma1)) == shared(inout int)[])); // <- NG
3731 static assert(is(typeof(fsc(swma2)) == shared(inout int)[]));
3732 static assert(is(typeof(fsc(swca1)) == shared(inout const int)[])); // <- NG
3733 static assert(is(typeof(fsc(swca2)) == shared(inout const int)[]));
3734
3735 /* Parameter is immutable
3736 */
3737 U fi(U)(immutable U) { return null; }
3738 // 9 * 2 - 1
3739 static assert(is(typeof(fi( ma1))) == false);
3740 static assert(is(typeof(fi( ca1))) == false);
3741 static assert(is(typeof(fi( ca2))) == false);
3742 static assert(is(typeof(fi( wma1))) == false);
3743 static assert(is(typeof(fi( wma2))) == false);
3744 static assert(is(typeof(fi( wca1))) == false);
3745 static assert(is(typeof(fi( wca2))) == false);
3746 static assert(is(typeof(fi( ia1)) == immutable(int)[])); // <- NG
3747 static assert(is(typeof(fi( ia2)) == immutable(int)[])); // <- NG
3748 static assert(is(typeof(fi( sma1))) == false);
3749 static assert(is(typeof(fi( sma2))) == false);
3750 static assert(is(typeof(fi( sca1))) == false);
3751 static assert(is(typeof(fi( sca2))) == false);
3752 static assert(is(typeof(fi(swma1))) == false);
3753 static assert(is(typeof(fi(swma2))) == false);
3754 static assert(is(typeof(fi(swca1))) == false);
3755 static assert(is(typeof(fi(swca2))) == false);
3756
3757 /* Parameter is (shared) inout
3758 */
3759 U f_w(U)( inout U) { return null; }
3760 U fsw(U)(shared inout U) { return null; }
3761 // 9 * 2 - 1
3762 static assert(is(typeof(f_w( ma1)) == int []));
3763 static assert(is(typeof(f_w( ca1)) == int [])); // <- const(int)[]
3764 static assert(is(typeof(f_w( ca2)) == int [])); // <- const(int)[]
3765 static assert(is(typeof(f_w( wma1)) == int [])); // <- inout(int)[]
3766 static assert(is(typeof(f_w( wma2)) == int [])); // <- inout(int)[]
3767 static assert(is(typeof(f_w( wca1)) == const(int)[])); // <- inout(const(int))[]
3768 static assert(is(typeof(f_w( wca2)) == const(int)[])); // <- inout(const(int))[]
3769 static assert(is(typeof(f_w( ia1)) == int [])); // <- immutable(int)[]
3770 static assert(is(typeof(f_w( ia2)) == int [])); // <- immutable(int)[]
3771 static assert(is(typeof(f_w( sma1)) == shared( int)[]));
3772 static assert(is(typeof(f_w( sma2)) == shared( int)[])); // <- shared(int[])
3773 static assert(is(typeof(f_w( sca1)) == shared( int)[])); // <- shared(const(int))[]
3774 static assert(is(typeof(f_w( sca2)) == shared( int)[])); // <- shared(const(int)[])
3775 static assert(is(typeof(f_w(swma1)) == shared( int)[])); // <- shared(inout(int))[]
3776 static assert(is(typeof(f_w(swma2)) == shared( int)[])); // <- shared(inout(int)[])
3777 static assert(is(typeof(f_w(swca1)) == shared(const int)[])); // <- shared(inout(const(int)))[]
3778 static assert(is(typeof(f_w(swca2)) == shared(const int)[])); // <- shared(inout(const(int))[])
3779 // 9 * 2 - 1
3780 static assert(is(typeof(fsw( ma1))) == false);
3781 static assert(is(typeof(fsw( ca1))) == false);
3782 static assert(is(typeof(fsw( ca2))) == false);
3783 static assert(is(typeof(fsw( wma1))) == false);
3784 static assert(is(typeof(fsw( wma2))) == false);
3785 static assert(is(typeof(fsw( wca1))) == false);
3786 static assert(is(typeof(fsw( wca2))) == false);
3787 static assert(is(typeof(fsw( ia1)) == int [])); // <- NG
3788 static assert(is(typeof(fsw( ia2)) == int [])); // <- NG
3789 static assert(is(typeof(fsw( sma1)) == int [])); // <- NG
3790 static assert(is(typeof(fsw( sma2)) == int []));
3791 static assert(is(typeof(fsw( sca1)) == int [])); // <- NG
3792 static assert(is(typeof(fsw( sca2)) == int [])); // const(int)[]
3793 static assert(is(typeof(fsw(swma1)) == int [])); // <- NG
3794 static assert(is(typeof(fsw(swma2)) == int [])); // inout(int)[]
3795 static assert(is(typeof(fsw(swca1)) == const(int)[])); // <- NG
3796 static assert(is(typeof(fsw(swca2)) == const(int)[])); // <- inout(const(int))[]
3797
3798 /* Parameter is (shared) inout const
3799 */
3800 U f_wc(U)( inout const U) { return null; }
3801 U fswc(U)(shared inout const U) { return null; }
3802 // 9 * 2 - 1
3803 static assert(is(typeof(f_wc( ma1)) == int []));
3804 static assert(is(typeof(f_wc( ca1)) == int [])); // <- const(int)[]
3805 static assert(is(typeof(f_wc( ca2)) == int [])); // <- const(int)[]
3806 static assert(is(typeof(f_wc( wma1)) == int [])); // <- inout(int)[]
3807 static assert(is(typeof(f_wc( wma2)) == int [])); // <- inout(int)[]
3808 static assert(is(typeof(f_wc( wca1)) == int [])); // <- inout(const(int))[]
3809 static assert(is(typeof(f_wc( wca2)) == int [])); // <- inout(const(int))[]
3810 static assert(is(typeof(f_wc( ia1)) == int [])); // <- immutable(int)[]
3811 static assert(is(typeof(f_wc( ia2)) == int [])); // <- immutable(int)[]
3812 static assert(is(typeof(f_wc( sma1)) == shared(int)[]));
3813 static assert(is(typeof(f_wc( sma2)) == shared(int)[])); // <- shared(int[])
3814 static assert(is(typeof(f_wc( sca1)) == shared(int)[])); // <- shared(const(int))[]
3815 static assert(is(typeof(f_wc( sca2)) == shared(int)[])); // <- shared(const(int)[])
3816 static assert(is(typeof(f_wc(swma1)) == shared(int)[])); // <- shared(inout(int))[]
3817 static assert(is(typeof(f_wc(swma2)) == shared(int)[])); // <- shared(inout(int)[])
3818 static assert(is(typeof(f_wc(swca1)) == shared(int)[])); // <- shared(inout(const(int)))[]
3819 static assert(is(typeof(f_wc(swca2)) == shared(int)[])); // <- shared(inout(const(int))[])
3820 // 9 * 2 - 1
3821 static assert(is(typeof(fswc( ma1))) == false);
3822 static assert(is(typeof(fswc( ca1))) == false);
3823 static assert(is(typeof(fswc( ca2))) == false);
3824 static assert(is(typeof(fswc( wma1))) == false);
3825 static assert(is(typeof(fswc( wma2))) == false);
3826 static assert(is(typeof(fswc( wca1))) == false);
3827 static assert(is(typeof(fswc( wca2))) == false);
3828 static assert(is(typeof(fswc( ia1)) == int [])); // <- NG
3829 static assert(is(typeof(fswc( ia2)) == int [])); // <- NG
3830 static assert(is(typeof(fswc( sma1)) == int [])); // <- NG
3831 static assert(is(typeof(fswc( sma2)) == int []));
3832 static assert(is(typeof(fswc( sca1)) == int [])); // <- NG
3833 static assert(is(typeof(fswc( sca2)) == int [])); // <- const(int)[]
3834 static assert(is(typeof(fswc(swma1)) == int [])); // <- NG
3835 static assert(is(typeof(fswc(swma2)) == int [])); // <- inout(int)[]
3836 static assert(is(typeof(fswc(swca1)) == int [])); // <- NG
3837 static assert(is(typeof(fswc(swca2)) == int [])); // <- inout(const(int))[]
3838 }+/
3839
3840 void test13127a()
3841 {
3842 void foo(T)(in T[] src, T[] dst) { static assert(is(T == int[])); }
3843
3844 int[][] a;
3845 foo(a, a);
3846 }
3847
3848 /******************************************/
3849 // 13159
3850
3851 template maxSize13159(T...)
3852 {
3853 static if (T.length == 1)
3854 {
3855 enum size_t maxSize13159 = T[0].sizeof;
3856 }
3857 else
3858 {
3859 enum size_t maxSize13159 =
3860 T[0].sizeof >= maxSize13159!(T[1 .. $])
3861 ? T[0].sizeof
3862 : maxSize13159!(T[1 .. $]);
3863 }
3864 }
3865
3866 struct Node13159
3867 {
3868 struct Pair
3869 {
3870 Node13159 value;
3871 }
3872
3873 //alias Algebraic!(Node[], int) Value;
3874 enum n = maxSize13159!(Node13159[], int);
3875 }
3876
3877 /******************************************/
3878 // 13180
3879
3880 void test13180()
3881 {
3882 inout(V) get1a(K, V)(inout(V[K]) aa, lazy inout(V) defaultValue)
3883 {
3884 static assert(is(V == string));
3885 static assert(is(K == string));
3886 return defaultValue;
3887 }
3888 inout(V) get1b(K, V)(lazy inout(V) defaultValue, inout(V[K]) aa)
3889 {
3890 static assert(is(V == string));
3891 static assert(is(K == string));
3892 return defaultValue;
3893 }
3894
3895 inout(V) get2a(K, V)(inout(V)[K] aa, lazy inout(V) defaultValue)
3896 {
3897 static assert(is(V == string));
3898 static assert(is(K == string));
3899 return defaultValue;
3900 }
3901 inout(V) get2b(K, V)(lazy inout(V) defaultValue, inout(V)[K] aa)
3902 {
3903 static assert(is(V == string));
3904 static assert(is(K == string));
3905 return defaultValue;
3906 }
3907 string def;
3908 string[string] aa;
3909 string s1a = get1a(aa, def);
3910 string s1b = get1b(def, aa);
3911 string s2a = get2a(aa, def);
3912 string s2b = get2b(def, aa);
3913 }
3914
3915 /******************************************/
3916 // 13204
3917
3918 struct A13204(uint v)
3919 {
3920 alias whatever = A13204y;
3921 static assert(is(whatever == A13204));
3922 }
3923 alias A13204x = A13204!1;
3924 alias A13204y = A13204x;
3925
3926 struct B13204(uint v)
3927 {
3928 alias whatever = B13204z;
3929 static assert(is(whatever == B13204));
3930 }
3931 alias B13204x = B13204!1;
3932 alias B13204y = B13204x;
3933 alias B13204z = B13204y;
3934
3935 void test13204()
3936 {
3937 static assert(is(A13204x == A13204!1));
3938 static assert(is(A13204x == A13204!1.whatever));
3939 static assert(is(A13204x == A13204y));
3940
3941 static assert(is(B13204x == B13204!1));
3942 static assert(is(B13204x == B13204!1.whatever));
3943 static assert(is(B13204x == B13204y));
3944 static assert(is(B13204x == B13204z));
3945 }
3946
3947 /******************************************/
3948 // 8462 (dup of 13204)
3949
3950 alias FP8462 = void function(C8462.Type arg);
3951
3952 class C8462
3953 {
3954 enum Type { Foo }
3955 alias funcPtrPtr = FP8462*;
3956 }
3957
3958 /******************************************/
3959 // 13218
3960
3961 template isCallable13218(T...)
3962 if (T.length == 1)
3963 {
3964 static assert(0);
3965 }
3966
3967 template ParameterTypeTuple13218(func...)
3968 if (func.length == 1 && isCallable13218!func)
3969 {
3970 static assert(0);
3971 }
3972
3973 struct R13218
3974 {
3975 private static string mangleFuncPtr(ArgTypes...)()
3976 {
3977 string result = "fnp_";
3978 foreach (T; ArgTypes)
3979 result ~= T.mangleof;
3980 return result;
3981 }
3982 void function(int) fnp_i;
3983 double delegate(double) fnp_d;
3984
3985 void opAssign(FnT)(FnT func)
3986 {
3987 mixin(mangleFuncPtr!( ParameterTypeTuple13218!FnT) ~ " = func;"); // parsed as TypeInstance
3988 //mixin(mangleFuncPtr!(.ParameterTypeTuple13218!FnT) ~ " = func;"); // parsed as DotTemplateInstanceExp -> works
3989 }
3990 }
3991
3992 /******************************************/
3993 // 13219
3994
3995 struct Map13219(V) {}
3996
3997 void test13219a(alias F, VA, VB)(Map13219!VA a, Map13219!VB b)
3998 if (is(VA : typeof(F(VA.init, VB.init))))
3999 {}
4000
4001 void test13219b(alias F)()
4002 {
4003 test13219a!((a, b) => b)(Map13219!int.init, Map13219!int.init);
4004 }
4005
4006 void test13219()
4007 {
4008 int x;
4009 test13219b!x();
4010 }
4011
4012 /******************************************/
4013 // 13223
4014
4015 void test13223()
4016 {
4017 T[] f1(T)(T[] a1, T[] a2)
4018 {
4019 static assert(is(T == int));
4020 return a1 ~ a2;
4021 }
4022 T[] f2(T)(T[] a1, T[] a2)
4023 {
4024 static assert(is(T == int));
4025 return a1 ~ a2;
4026 }
4027 int[] a = [1, 2];
4028 static assert(is(typeof(f1(a, [])) == int[]));
4029 static assert(is(typeof(f2([], a)) == int[]));
4030 static assert(is(typeof(f1(a, null)) == int[]));
4031 static assert(is(typeof(f2(null, a)) == int[]));
4032
4033 T[] f3(T)(T[] a) { return a; }
4034 static assert(is(typeof(f3([])) == void[]));
4035 static assert(is(typeof(f3(null)) == void[]));
4036
4037 T f4(T)(T a) { return a; }
4038 static assert(is(typeof(f4([])) == void[]));
4039 static assert(is(typeof(f4(null)) == typeof(null)));
4040
4041 T[][] f5(T)(T[][] a) { return a; }
4042 static assert(is(typeof(f5([])) == void[][]));
4043 static assert(is(typeof(f5(null)) == void[][]));
4044
4045 void translate(C = immutable char)(const(C)[] toRemove)
4046 {
4047 static assert(is(C == char));
4048 }
4049 translate(null);
4050 }
4051
4052 void test13223a()
4053 {
4054 T f(T)(T, T) { return T.init; }
4055
4056 immutable i = 0;
4057 const c = 0;
4058 auto m = 0;
4059 shared s = 0;
4060
4061 static assert(is(typeof(f(i, i)) == immutable int));
4062 static assert(is(typeof(f(i, c)) == const int));
4063 static assert(is(typeof(f(c, i)) == const int));
4064 static assert(is(typeof(f(i, m)) == int));
4065 static assert(is(typeof(f(m, i)) == int));
4066 static assert(is(typeof(f(c, m)) == int));
4067 static assert(is(typeof(f(m, c)) == int));
4068 static assert(is(typeof(f(m, m)) == int));
4069 static assert(is(typeof(f(i, s)) == shared int));
4070 static assert(is(typeof(f(s, i)) == shared int));
4071 static assert(is(typeof(f(c, s)) == shared int));
4072 static assert(is(typeof(f(s, c)) == shared int));
4073 static assert(is(typeof(f(s, s)) == shared int));
4074 static assert(is(typeof(f(s, m)) == int));
4075 static assert(is(typeof(f(m, s)) == int));
4076 }
4077
4078 /******************************************/
4079 // 13235
4080
4081 struct Tuple13235(T...)
4082 {
4083 T expand;
4084 alias expand field;
4085
4086 this(T values)
4087 {
4088 field = values;
4089 }
4090 }
4091 struct Foo13235
4092 {
4093 Tuple13235!(int, Foo13235)* foo;
4094 }
4095
4096 template Inst13235(T...)
4097 {
4098 struct Tuple
4099 {
4100 T expand;
4101 alias expand field;
4102
4103 this(T values)
4104 {
4105 field = values;
4106 }
4107 }
4108 alias Inst13235 = Tuple*;
4109 }
4110 struct Bar13235
4111 {
4112 Inst13235!(int, Bar13235) bar;
4113 }
4114
4115 void test13235()
4116 {
4117 alias Tup1 = Tuple13235!(int, Foo13235);
4118 assert(Tup1(1, Foo13235()).expand[0] == 1);
4119
4120 alias Tup2 = typeof(*Inst13235!(int, Bar13235).init);
4121 assert(Tup2(1, Bar13235()).expand[0] == 1);
4122 }
4123
4124 /******************************************/
4125 // 13252
4126
4127 alias TypeTuple13252(T...) = T;
4128
4129 static assert(is(typeof(TypeTuple13252!(cast(int )1)[0]) == int ));
4130 static assert(is(typeof(TypeTuple13252!(cast(long)1)[0]) == long));
4131
4132 static assert(is(typeof(TypeTuple13252!(cast(float )3.14)[0]) == float ));
4133 static assert(is(typeof(TypeTuple13252!(cast(double)3.14)[0]) == double));
4134
4135 static assert(is(typeof(TypeTuple13252!(cast(cfloat )(1 + 2i))[0]) == cfloat ));
4136 static assert(is(typeof(TypeTuple13252!(cast(cdouble)(1 + 2i))[0]) == cdouble));
4137
4138 static assert(is(typeof(TypeTuple13252!(cast(string )null)[0]) == string ));
4139 static assert(is(typeof(TypeTuple13252!(cast(string[])null)[0]) == string[])); // OK <- NG
4140
4141 static assert(is(typeof(TypeTuple13252!(cast(wstring)"abc")[0]) == wstring));
4142 static assert(is(typeof(TypeTuple13252!(cast(dstring)"abc")[0]) == dstring));
4143
4144 static assert(is(typeof(TypeTuple13252!(cast(int[] )[])[0]) == int[] ));
4145 static assert(is(typeof(TypeTuple13252!(cast(long[])[])[0]) == long[])); // OK <- NG
4146
4147 struct S13252 { }
4148 static assert(is(typeof(TypeTuple13252!(const S13252())[0]) == const(S13252)));
4149 static assert(is(typeof(TypeTuple13252!(immutable S13252())[0]) == immutable(S13252))); // OK <- NG
4150
4151 /******************************************/
4152 // 13294
4153
4154 void test13294()
4155 {
4156 void f(T)(const ref T src, ref T dst)
4157 {
4158 pragma(msg, "T = ", T);
4159 static assert(!is(T == const));
4160 }
4161 {
4162 const byte src;
4163 byte dst;
4164 f(src, dst);
4165 }
4166 {
4167 const char src;
4168 char dst;
4169 f(src, dst);
4170 }
4171
4172 // 13351
4173 T add(T)(in T x, in T y)
4174 {
4175 T z;
4176 z = x + y;
4177 return z;
4178 }
4179 const double a = 1.0;
4180 const double b = 2.0;
4181 double c;
4182 c = add(a,b);
4183 }
4184
4185 /******************************************/
4186 // 13299
4187
4188 struct Foo13299
4189 {
4190 Foo13299 opDispatch(string name)(int a, int[] b...)
4191 if (name == "bar")
4192 {
4193 return Foo13299();
4194 }
4195
4196 Foo13299 opDispatch(string name)()
4197 if (name != "bar")
4198 {
4199 return Foo13299();
4200 }
4201 }
4202
4203 void test13299()
4204 {
4205 Foo13299()
4206 .bar(0)
4207 .bar(1)
4208 .bar(2);
4209
4210 Foo13299()
4211 .opDispatch!"bar"(0)
4212 .opDispatch!"bar"(1)
4213 .opDispatch!"bar"(2);
4214 }
4215
4216 /******************************************/
4217 // 13333
4218
4219 template AliasThisTypeOf13333(T)
4220 {
4221 static assert(0, T.stringof); // T.stringof is important
4222 }
4223
4224 template StaticArrayTypeOf13333(T)
4225 {
4226 static if (is(AliasThisTypeOf13333!T AT))
4227 alias X = StaticArrayTypeOf13333!AT;
4228 else
4229 alias X = T;
4230
4231 static if (is(X : E[n], E, size_t n))
4232 alias StaticArrayTypeOf13333 = X;
4233 else
4234 static assert(0, T.stringof~" is not a static array type");
4235 }
4236
4237 enum bool isStaticArray13333(T) = is(StaticArrayTypeOf13333!T);
4238
4239 struct VaraiantN13333(T)
4240 {
4241 static if (isStaticArray13333!T)
4242 ~this() { static assert(0); }
4243 }
4244
4245 struct DummyScope13333
4246 {
4247 alias A = VaraiantN13333!C;
4248
4249 static class C
4250 {
4251 A entity;
4252 }
4253 }
4254
4255 void test13333()
4256 {
4257 struct DummyScope
4258 {
4259 alias A = VaraiantN13333!C;
4260
4261 static class C
4262 {
4263 A entity;
4264 }
4265 }
4266 }
4267
4268 /******************************************/
4269 // 13374
4270
4271 int f13374(alias a)() { return 1; }
4272 int f13374(string s)() { return 2; }
4273
4274 void x13374(int i) {}
4275
4276 void test13374()
4277 {
4278 assert(f13374!x13374() == 1);
4279 }
4280
4281 /******************************************/
4282 // 14109
4283
4284 string f14109() { return "a"; }
4285 string g14109()() { return "a"; }
4286
4287 struct S14109(string s) { static assert(s == "a"); }
4288
4289 alias X14109 = S14109!(f14109);
4290 alias Y14109 = S14109!(g14109!());
4291 static assert(is(X14109 == Y14109));
4292
4293 /******************************************/
4294 // 13378
4295
4296 struct Vec13378(size_t n, T, string as)
4297 {
4298 T[n] data;
4299 }
4300
4301 void doSome13378(size_t n, T, string as)(Vec13378!(n,T,as) v) {}
4302
4303 void test13378()
4304 {
4305 auto v = Vec13378!(3, float, "xyz")([1,2,3]);
4306 doSome13378(v);
4307 }
4308
4309 /******************************************/
4310 // 13379
4311
4312 void test13379()
4313 {
4314 match13379("");
4315 }
4316
4317 auto match13379(RegEx )(RegEx re)
4318 if (is(RegEx == Regex13379!char)) // #1 Regex!char (speculative && tinst == NULL)
4319 {}
4320 auto match13379(String)(String re)
4321 {}
4322
4323 struct Regex13379(Char)
4324 {
4325 ShiftOr13379!Char kickstart; // #2 ShiftOr!char (speculative && tinst == Regex!char)
4326 }
4327 struct ShiftOr13379(Char)
4328 {
4329 this(ref Regex13379!Char re) // #3 Regex!Char (speculative && tinst == ShiftOr!char)
4330 {
4331 uint n_length;
4332 uint idx;
4333 n_length = min13379(idx, n_length);
4334 }
4335 }
4336
4337 template MinType13379(T...)
4338 {
4339 alias MinType13379 = T[0];
4340 }
4341 MinType13379!T min13379(T...)(T args) // #4 MinType!uint (speculative && thist == ShiftOr!char)
4342 {
4343 alias a = args[0];
4344 alias b = args[$-1];
4345 return cast(typeof(return)) (a < b ? a : b);
4346 }
4347
4348 /******************************************/
4349 // 13417
4350
4351 struct V13417(size_t N, E, alias string AS)
4352 {
4353 }
4354
4355 auto f13417(E)(in V13417!(4, E, "ijka"))
4356 {
4357 return V13417!(3, E, "xyz")();
4358 }
4359
4360 void test13417()
4361 {
4362 f13417(V13417!(4, float, "ijka")());
4363 }
4364
4365 /******************************************/
4366 // 13484
4367
4368 int foo13484()(void delegate() hi) { return 1; }
4369 int foo13484(T)(void delegate(T) hi) { return 2; }
4370
4371 void test13484()
4372 {
4373 assert(foo13484({}) == 1); // works
4374 assert(foo13484((float v){}) == 2); // works <- throws error
4375 }
4376
4377 /******************************************/
4378 // 13675
4379
4380 enum E13675;
4381
4382 bool foo13675(T : E13675)()
4383 {
4384 return false;
4385 }
4386
4387 void test13675()
4388 {
4389 if (foo13675!E13675)
4390 {}
4391 }
4392
4393 /******************************************/
4394 // 13694
4395
4396 auto foo13694(T)(string A, T[] G ...) { return 1; }
4397 auto foo13694(T)(string A, long E, T[] G ...) { return 2; }
4398
4399 void test13694()
4400 {
4401 struct S {}
4402
4403 S v;
4404 assert(foo13694("A", v) == 1); // <- OK
4405 assert(foo13694("A", 0, v) == 2); // <- used to be OK but now fails
4406 assert(foo13694!S("A", 0, v) == 2); // <- workaround solution
4407 }
4408
4409 /******************************************/
4410 // 13760
4411
4412 void test13760()
4413 {
4414 void func(K, V)(inout(V[K]) aa, inout(V) val) {}
4415
4416 class C {}
4417 C[int] aa;
4418 func(aa, new C);
4419 }
4420
4421 /******************************************/
4422 // 13714
4423
4424 struct JSONValue13714
4425 {
4426 this(T)(T arg)
4427 {
4428 }
4429 this(T : JSONValue13714)(inout T arg) inout
4430 {
4431 //store = arg.store;
4432 }
4433
4434 void opAssign(T)(T arg)
4435 {
4436 }
4437 }
4438
4439 void test13714()
4440 {
4441 enum DummyStringEnum
4442 {
4443 foo = "bar"
4444 }
4445
4446 JSONValue13714[string] aa;
4447 aa["A"] = DummyStringEnum.foo;
4448 }
4449
4450 /******************************************/
4451 // 13807
4452
4453 T f13807(T)(inout(T)[] arr)
4454 {
4455 return T.init;
4456 }
4457
4458 void test13807()
4459 {
4460 static assert(is(typeof(f13807([1, 2, 3])) == int)); // OK
4461 static assert(is(typeof(f13807(["a", "b"])) == string)); // OK <- Error
4462 static assert(is(typeof(f13807!string(["a", "b"])) == string)); // OK
4463 }
4464
4465 /******************************************/
4466 // 14174
4467
4468 struct Config14174(a, b) {}
4469
4470 struct N14174 {}
4471
4472 alias defConfig14174 = Config14174!(N14174, N14174);
4473
4474 void accepter14174a(Config : Config14174!(T) = defConfig14174, T...)()
4475 {
4476 static assert(accepter14174a.mangleof
4477 == "_D7breaker131__T14"~
4478 "accepter14174a"~
4479 "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~
4480 "accepter14174a"~
4481 "FZv");
4482 }
4483
4484 void accepter14174b(Config : Config14174!(T) = defConfig14174, T...)()
4485 {
4486 static assert(accepter14174b.mangleof
4487 == "_D7breaker131__T14"~
4488 "accepter14174b"~
4489 "HTS7breaker51__T11Config14174TS7breaker6N14174TS7breaker6N14174Z11Config14174TS7breaker6N14174TS7breaker6N14174Z14"~
4490 "accepter14174b"~
4491 "FZv");
4492 }
4493
4494 void test14174()
4495 {
4496 accepter14174a!()(); // ok
4497 accepter14174b(); // error
4498 }
4499
4500 /******************************************/
4501 // 14836
4502
4503 template a14836x(alias B, C...)
4504 {
4505 int a14836x(D...)() if (D.length == 0) { return 1; }
4506 int a14836x(D...)(D d) if (D.length > 0) { return 2; }
4507 }
4508 template a14836y(alias B, C...)
4509 {
4510 int a14836y(T, D...)(T t) if (D.length == 0) { return 1; }
4511 int a14836y(T, D...)(T t, D d) if (D.length > 0) { return 2; }
4512 }
4513
4514 void test14836()
4515 {
4516 int v;
4517 assert(a14836x!(v)() == 1);
4518 assert(a14836x!(v)(1) == 2);
4519 assert(a14836y!(v)(1) == 1);
4520 assert(a14836y!(v)(1, 2) == 2);
4521 }
4522
4523 /******************************************/
4524 // 14357
4525
4526 template Qux14357(T : U*, U : V*, V)
4527 {
4528 pragma(msg, T); // no match <- float**
4529 pragma(msg, U); // no match <- float*
4530 pragma(msg, V); // no match <- int
4531 enum Qux14357 = T.sizeof + V.sizeof;
4532 }
4533 static assert(!__traits(compiles, Qux14357!(float**, int*)));
4534
4535 /******************************************/
4536 // 14481
4537
4538 template someT14481(alias e)
4539 {
4540 alias someT14481 = e;
4541 }
4542
4543 mixin template Mix14481(alias e)
4544 {
4545 alias SomeAlias = someT14481!e;
4546 }
4547
4548 struct Hoge14481
4549 {
4550 mixin Mix14481!e;
4551 enum e = 10;
4552 }
4553
4554 /******************************************/
4555 // 14520
4556
4557 template M14520(alias a) { enum M14520 = 1; }
4558 template M14520(string s) { enum M14520 = 2; }
4559
4560 int f14520a();
4561 string f14520b() { assert(0); }
4562 string f14520c() { return "a"; }
4563
4564 static assert(M14520!f14520a == 1);
4565 static assert(M14520!f14520b == 1);
4566 static assert(M14520!f14520c == 1);
4567
4568 /******************************************/
4569 // 14568
4570
4571 struct Interval14568()
4572 {
4573 auto left = INVALID;
4574
4575 auto opAssign()(Interval14568) { left; }
4576 }
4577
4578 auto interval14568(T)(T point)
4579 {
4580 Interval14568!();
4581 }
4582
4583 alias Instantiate14568(alias symbol, Args...) = symbol!Args;
4584
4585 template Match14568(patterns...)
4586 {
4587 static if (__traits(compiles, Instantiate14568!(patterns[0])))
4588 {
4589 alias Match14568 = patterns[0];
4590 }
4591 else static if (patterns.length == 1)
4592 {}
4593 }
4594
4595 template SubOps14568(Args...)
4596 {
4597 auto opIndex()
4598 {
4599 template IntervalType(T...)
4600 {
4601 alias Point() = typeof(T.interval14568);
4602
4603 alias IntervalType = Match14568!(Point);
4604 }
4605 alias Subspace = IntervalType!(Args);
4606 }
4607 }
4608
4609 struct Nat14568 { mixin SubOps14568!(null); }
4610
4611 /******************************************/
4612 // 14603, 14604
4613
4614 struct S14603
4615 {
4616 template opDispatch(string name)
4617 {
4618 void opDispatch()() {}
4619 }
4620 }
4621 alias a14603 = S14603.opDispatch!"go"; // OK
4622 alias b14603 = S14603.go; // OK <- NG
4623
4624 struct S14604
4625 {
4626 template opDispatch(string name)
4627 {
4628 void opDispatch()() {}
4629 }
4630 }
4631 alias Id14604(alias thing) = thing;
4632 alias c14604 = Id14604!(S14604.opDispatch!"go"); // ok
4633 alias d14604 = Id14604!(S14604.go); // issue 14604, 'Error: template instance opDispatch!"go" cannot resolve forward reference'
4634
4635 /******************************************/
4636 // 14735
4637
4638 enum CS14735 { yes, no }
4639
4640 int indexOf14735a(Range )(Range s, in dchar c) { return 1; }
4641 int indexOf14735a(T, size_t n)(ref T[n] s, in dchar c) { return 2; }
4642
4643 int indexOf14735b(Range )(Range s, in dchar c, in CS14735 cs = CS14735.yes) { return 1; }
4644 int indexOf14735b(T, size_t n)(ref T[n] s, in dchar c, in CS14735 cs = CS14735.yes) { return 2; }
4645
4646 void test14735()
4647 {
4648 char[64] buf;
4649
4650 // Supported from 2.063: (http://dlang.org/changelog#implicitarraycast)
4651 assert(indexOf14735a(buf[0..32], '\0') == 2);
4652 assert(indexOf14735b(buf[0..32], '\0') == 2);
4653
4654 // Have to work as same as above.
4655 assert(indexOf14735a(buf[], '\0') == 2);
4656 assert(indexOf14735b(buf[], '\0') == 2);
4657 }
4658
4659 /******************************************/
4660 // 14743
4661
4662 class A14743
4663 {
4664 auto func1 = (A14743 a) { a.func2!int(); };
4665 auto func2(T)() {}
4666 }
4667
4668 /******************************************/
4669 // 14802
4670
4671 void test14802()
4672 {
4673 auto func(T)(T x, T y) { return x; }
4674
4675 struct S1 { double x; alias x this; }
4676 struct S2 { double x; alias x this; }
4677 S1 s1;
4678 S2 s2;
4679
4680 enum E1 : double { a = 1.0 }
4681 enum E2 : double { a = 1.0 }
4682
4683 static assert(is(typeof( func(1 , 1 ) ) == int));
4684 static assert(is(typeof( func(1u, 1u) ) == uint));
4685 static assert(is(typeof( func(1u, 1 ) ) == uint));
4686 static assert(is(typeof( func(1 , 1u) ) == uint));
4687
4688 static assert(is(typeof( func(1.0f, 1.0f) ) == float));
4689 static assert(is(typeof( func(1.0 , 1.0 ) ) == double));
4690 static assert(is(typeof( func(1.0 , 1.0f) ) == double));
4691 static assert(is(typeof( func(1.0f, 1.0 ) ) == double));
4692
4693 static assert(is(typeof( func(s1, s1) ) == S1));
4694 static assert(is(typeof( func(s2, s2) ) == S2));
4695 static assert(is(typeof( func(s1, s2) ) == double));
4696 static assert(is(typeof( func(s2, s1) ) == double));
4697
4698 static assert(is(typeof( func(E1.a, E1.a) ) == E1));
4699 static assert(is(typeof( func(E2.a, E2.a) ) == E2));
4700 static assert(is(typeof( func(E1.a, 1.0) ) == double));
4701 static assert(is(typeof( func(E2.a, 1.0) ) == double));
4702 static assert(is(typeof( func(1.0, E1.a) ) == double));
4703 static assert(is(typeof( func(1.0, E2.a) ) == double));
4704 static assert(is(typeof( func(E1.a, E2.a) ) == double));
4705 static assert(is(typeof( func(E2.a, E1.a) ) == double));
4706 }
4707
4708 /******************************************/
4709 // 14886
4710
4711 void test14886()
4712 {
4713 alias R = int[100_000];
4714
4715 auto front(T)(T[] a) {}
4716 front(R.init);
4717
4718 auto bar1(T)(T, T[] a) { return T.init; }
4719 auto bar2(T)(T[] a, T) { return T.init; }
4720
4721 static assert(is(typeof(bar1(1L, R.init)) == long));
4722 static assert(is(typeof(bar2(R.init, 1L)) == long));
4723 // <-- T should be deduced to int because R.init is rvalue...?
4724
4725 ubyte x;
4726 static assert(is(typeof(bar1(x, R.init)) == int));
4727 static assert(is(typeof(bar2(R.init, x)) == int));
4728 }
4729
4730 /******************************************/
4731 // 15156
4732
4733 // 15156
4734 auto f15116a(T)(string s, string arg2) { return 1; }
4735 auto f15116b(T)(int i, string arg2) { return 2; }
4736
4737 template bish15116(T)
4738 {
4739 alias bish15116 = f15116a!T;
4740 alias bish15116 = f15116b!T;
4741 }
4742
4743 void test15116()
4744 {
4745 alias func = bish15116!string;
4746 assert(func("", "") == 1);
4747 assert(func(12, "") == 2);
4748 }
4749
4750 /******************************************/
4751 // 15152
4752
4753 void test15152()
4754 {
4755 void func(string M)() { }
4756
4757 struct S
4758 {
4759 enum name = "a";
4760 }
4761
4762 enum s = S.init;
4763 func!(s.name);
4764 }
4765
4766 /******************************************/
4767 // 15352
4768
4769 struct S15352(T, T delegate(uint idx) supplier)
4770 {
4771 }
4772
4773 auto make15352a(T, T delegate(uint idx) supplier)()
4774 {
4775 enum local = supplier; // OK
4776 S15352!(T, local) ret;
4777 return ret;
4778 }
4779
4780 auto make15352b(T, T delegate(uint idx) supplier)()
4781 {
4782 S15352!(T, supplier) ret; // OK <- Error
4783 return ret;
4784 }
4785
4786 void test15352()
4787 {
4788 enum dg = delegate(uint idx) => idx;
4789 auto s1 = S15352!(uint, dg)();
4790 auto s2 = make15352a!(uint, dg)();
4791 auto s3 = make15352b!(uint, dg)();
4792 assert(is(typeof(s1) == typeof(s2)));
4793 assert(is(typeof(s1) == typeof(s3)));
4794 }
4795
4796 /******************************************/
4797 // 15623
4798
4799 struct WithFoo15623a { void foo() {} }
4800 struct WithFoo15623b { void foo() {} }
4801 struct WithFoo15623c { void foo() {} }
4802 struct WithFoo15623d { void foo() {} }
4803
4804 struct WithoutFoo15623a {}
4805 struct WithoutFoo15623b {}
4806 struct WithoutFoo15623c {}
4807 struct WithoutFoo15623d {}
4808
4809 struct CallsFoo15623(T)
4810 {
4811 T t;
4812 void bar() { t.foo(); } // error occurs during TemplateInstance.semantic3
4813 }
4814
4815 // Instantiations outside of function bodies
4816 static assert( is(CallsFoo15623!WithFoo15623a));
4817 static assert(!is(CallsFoo15623!WithoutFoo15623a)); // OK <- NG
4818 static assert( __traits(compiles, CallsFoo15623!WithFoo15623b));
4819 static assert(!__traits(compiles, CallsFoo15623!WithoutFoo15623b)); // OK <- NG
4820
4821 // Instantiations inside function bodies (OK)
4822 static assert( is(typeof({ alias Baz = CallsFoo15623!WithFoo15623c; return Baz.init; }())));
4823 static assert(!is(typeof({ alias Baz = CallsFoo15623!WithoutFoo15623c; return Baz.init; }())));
4824 static assert( __traits(compiles, { alias Baz = CallsFoo15623!WithFoo15623d; return Baz.init; }()));
4825 static assert(!__traits(compiles, { alias Baz = CallsFoo15623!WithoutFoo15623d; return Baz.init; }()));
4826
4827 /******************************************/
4828 // 15781
4829
4830 void test15781()
4831 {
4832 static struct S
4833 {
4834 int value;
4835 }
4836
4837 T foo(T)(T a, T b)
4838 {
4839 return T();
4840 }
4841
4842 const S cs;
4843 S ms;
4844 static assert(is(typeof(foo(ms, ms)) == S));
4845 static assert(is(typeof(foo(ms, cs)) == const S));
4846 static assert(is(typeof(foo(cs, ms)) == const S));
4847 static assert(is(typeof(foo(cs, cs)) == const S));
4848 }
4849
4850 /******************************************/
4851
4852 int main()
4853 {
4854 test1();
4855 test2();
4856 test3();
4857 test4();
4858 test5();
4859 test6();
4860 test7();
4861 test8();
4862 test9();
4863 test1780();
4864 test3608();
4865 test5893();
4866 test6404();
4867 test2246();
4868 test2296();
4869 bug4984();
4870 test2579();
4871 test2803();
4872 test6613();
4873 test5886();
4874 test5393();
4875 test5896();
4876 test6825();
4877 test6789();
4878 test2778();
4879 test2778aa();
4880 test2778get();
4881 test6208a();
4882 test6208b();
4883 test6208c();
4884 test6738();
4885 test6780();
4886 test6810();
4887 test6891();
4888 test6994();
4889 test6764();
4890 test3467();
4891 test4413();
4892 test5525();
4893 test5801();
4894 test10();
4895 test7037();
4896 test7124();
4897 test7359();
4898 test7416();
4899 test7563();
4900 test7572();
4901 test7580();
4902 test7585();
4903 test7671();
4904 test7672();
4905 test7684();
4906 test11a();
4907 test11b();
4908 test7769();
4909 test7873();
4910 test7933();
4911 test8094();
4912 test12();
4913 test8125();
4914 test13();
4915 test14();
4916 test8129();
4917 test8238();
4918 test8669();
4919 test8833();
4920 test8976();
4921 test8940();
4922 test9022();
4923 test9026();
4924 test9038();
4925 test9076();
4926 test9100();
4927 test9124a();
4928 test9124b();
4929 test9143();
4930 test9266();
4931 test9536();
4932 test9578();
4933 test9596();
4934 test9837();
4935 test9874();
4936 test9885();
4937 test9971();
4938 test9977();
4939 test10083();
4940 test10592();
4941 test11242();
4942 test10811();
4943 test10969();
4944 test11271();
4945 test11533();
4946 test11818();
4947 test11843();
4948 test11872();
4949 test12122();
4950 test12207();
4951 test12376();
4952 test13235();
4953 test13294();
4954 test13299();
4955 test13374();
4956 test13378();
4957 test13379();
4958 test13484();
4959 test13694();
4960 test14836();
4961 test14735();
4962 test14802();
4963 test15116();
4964
4965 printf("Success\n");
4966 return 0;
4967 }
4968