blob: 0dbd2876d4edd5c9f34513eb62d23677dd1d6525 [file] [log] [blame]
/*
TEST_OUTPUT:
---
S7019(16), 16
S7019(24), 24
S7019(32), 32
---
RUN_OUTPUT:
---
Success
---
*/
extern(C) int printf(const char*, ...);
/***************************************************/
// 6475
class Foo6475(Value)
{
template T1(size_t n){ alias int T1; }
}
void test6475()
{
alias Foo6475!(int) C1;
alias C1.T1!0 X1;
static assert(is(X1 == int));
alias const(Foo6475!(int)) C2;
alias C2.T1!0 X2;
static assert(is(X2 == int));
}
/***************************************************/
// 6905
void test6905()
{
auto foo1() { static int n; return n; }
auto foo2() { int n; return n; }
auto foo3() { return 1; }
static assert(typeof(&foo1).stringof == "int delegate() nothrow @nogc @safe");
static assert(typeof(&foo2).stringof == "int delegate() pure nothrow @nogc @safe");
static assert(typeof(&foo3).stringof == "int delegate() pure nothrow @nogc @safe");
ref bar1() { static int n; return n; }
static assert(!__traits(compiles, {
ref bar2() { int n; return n; }
}));
static assert(!__traits(compiles, {
ref bar3() { return 1; }
}));
auto ref baz1() { static int n; return n; }
auto ref baz2() { int n; return n; }
auto ref baz3() { return 1; }
static assert(typeof(&baz1).stringof == "int delegate() nothrow @nogc ref @safe");
static assert(typeof(&baz2).stringof == "int delegate() pure nothrow @nogc @safe");
static assert(typeof(&baz3).stringof == "int delegate() pure nothrow @nogc @safe");
}
/***************************************************/
// 7019
struct S7019
{
int store;
this(int n)
{
store = n << 3;
}
}
S7019 rt_gs = 2;
enum S7019 ct_gs = 2;
pragma(msg, ct_gs, ", ", ct_gs.store);
void test7019()
{
S7019 rt_ls = 3; // this compiles fine
enum S7019 ct_ls = 3;
pragma(msg, ct_ls, ", ", ct_ls.store);
static class C
{
S7019 rt_fs = 4;
enum S7019 ct_fs = 4;
pragma(msg, ct_fs, ", ", ct_fs.store);
}
auto c = new C;
assert(rt_gs == S7019(2) && rt_gs.store == 16);
assert(rt_ls == S7019(3) && rt_ls.store == 24);
assert(c.rt_fs == S7019(4) && c.rt_fs.store == 32);
static assert(ct_gs == S7019(2) && ct_gs.store == 16);
static assert(ct_ls == S7019(3) && ct_ls.store == 24);
static assert(C.ct_fs == S7019(4) && C.ct_fs.store == 32);
void foo(S7019 s = 5) // fixing bug 7152
{
assert(s.store == 5 << 3);
}
foo();
}
/***************************************************/
// 7239
struct vec7239
{
float x, y, z, w;
alias x r; //! for color access
alias y g; //! ditto
alias z b; //! ditto
alias w a; //! ditto
}
void test7239()
{
vec7239 a = {x: 0, g: 0, b: 0, a: 1};
assert(a.r == 0);
assert(a.g == 0);
assert(a.b == 0);
assert(a.a == 1);
}
/***************************************************/
struct S10635
{
string str;
this(string[] v) { str = v[0]; }
this(string[string] v) { str = v.keys[0]; }
}
S10635 s10635a = ["getnonce"];
S10635 s10635b = ["getnonce" : "str"];
void test10635()
{
S10635 sa = ["getnonce"];
S10635 sb = ["getnonce" : "str"];
}
/***************************************************/
// 8123
void test8123()
{
struct S { }
struct AS
{
alias S Alias;
}
struct Wrapper
{
AS as;
}
Wrapper w;
static assert(is(typeof(w.as).Alias == S)); // fail
static assert(is(AS.Alias == S)); // ok
static assert(is(typeof(w.as) == AS)); // ok
static assert(is(typeof(w.as).Alias == AS.Alias)); // fail
}
/***************************************************/
// 8147
enum A8147 { a, b, c }
@property ref T front8147(T)(T[] a)
if (!is(T[] == void[]))
{
return a[0];
}
template ElementType8147(R)
{
static if (is(typeof({ R r = void; return r.front8147; }()) T))
alias T ElementType8147;
else
alias void ElementType8147;
}
void test8147()
{
auto arr = [A8147.a];
alias typeof(arr) R;
auto e = ElementType8147!R.init;
}
/***************************************************/
// 8410
void test8410()
{
struct Foo { int[15] x; string s; }
Foo[5] a1 = Foo([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "hello"); // OK
Foo f = { s: "hello" }; // OK (not static)
Foo[5] a2 = { s: "hello" }; // error
}
/***************************************************/
// 8942
alias const int A8942_0;
static assert(is(A8942_0 == const int)); // passes
void test8942()
{
alias const int A8942_1;
static assert(is(A8942_1 == const int)); // passes
static struct S { int i; }
foreach (Unused; typeof(S.tupleof))
{
alias const(int) A8942_2;
static assert(is(A8942_2 == const int)); // also passes
alias const int A8942_3;
static assert(is(A8942_3 == const int)); // fails
// Error: static assert (is(int == const(int))) is false
}
}
/***************************************************/
// 10144
final class TNFA10144(char_t)
{
enum Act { don }
const Act[] action_lookup1 = [ Act.don, ];
}
alias X10144 = TNFA10144!char;
class C10144
{
enum Act { don }
synchronized { enum x1 = [Act.don]; }
override { enum x2 = [Act.don]; }
abstract { enum x3 = [Act.don]; }
final { enum x4 = [Act.don]; }
synchronized { static s1 = [Act.don]; }
override { static s2 = [Act.don]; }
abstract { static s3 = [Act.don]; }
final { static s4 = [Act.don]; }
synchronized { __gshared gs1 = [Act.don]; }
override { __gshared gs2 = [Act.don]; }
abstract { __gshared gs3 = [Act.don]; }
final { __gshared gs4 = [Act.don]; }
}
/***************************************************/
// 10142
class File10142
{
enum Access : ubyte { Read = 0x01 }
enum Open : ubyte { Exists = 0 }
enum Share : ubyte { None = 0 }
enum Cache : ubyte { None = 0x00 }
struct Style
{
Access access;
Open open;
Share share;
Cache cache;
}
enum Style ReadExisting = { Access.Read, Open.Exists };
this (const(char[]) path, Style style = ReadExisting)
{
assert(style.access == Access.Read);
assert(style.open == Open .Exists);
assert(style.share == Share .None);
assert(style.cache == Cache .None);
}
}
void test10142()
{
auto f = new File10142("dummy");
}
/***************************************************/
// 11421
void test11421()
{
// AAs in array
const a1 = [[1:2], [3:4]]; // ok <- error
const int[int][] a2 = [[1:2], [3:4]]; // ok
static assert(is(typeof(a1) == typeof(a2)));
// AAs in AA
auto aa = [1:["a":1.0], 2:["b":2.0]];
static assert(is(typeof(aa) == double[string][int]));
assert(aa[1]["a"] == 1.0);
assert(aa[2]["b"] == 2.0);
}
/***************************************************/
// 13776
enum a13776(T) = __traits(compiles, { T; });
enum b13776(A...) = 1;
template x13776s()
{
struct S;
alias x13776s = b13776!(a13776!S);
}
template y13776s()
{
struct S;
alias x2 = b13776!(a13776!S);
alias y13776s = x2;
}
template z13776s()
{
struct S;
alias x1 = a13776!S;
alias x2 = b13776!(x1);
alias z13776s = x2;
}
template x13776c()
{
class C;
alias x13776c = b13776!(a13776!C);
}
template y13776c()
{
class C;
alias x2 = b13776!(a13776!C);
alias y13776c = x2;
}
template z13776c()
{
class C;
alias x1 = a13776!C;
alias x2 = b13776!(x1);
alias z13776c = x2;
}
void test13776()
{
alias xs = x13776s!(); // ok <- ng
alias ys = y13776s!(); // ok <- ng
alias zs = z13776s!(); // ok
alias xc = x13776c!(); // ok <- ng
alias yc = y13776c!(); // ok <- ng
alias zc = z13776c!(); // ok
}
/***************************************************/
// 14090
template Packed14090(Args...)
{
enum x = __traits(compiles, { Args[0] v; });
// Args[0] is an opaque struct Empty, so the variable declaration fails to compile.
// The error message creation calls TypeStruct('_Empty')->toChars(), and
// it wrongly calls TemplateInstance('RoundRobin!()')->toAlias().
// Finally it will cause incorrect "recursive template instantiation" error.
}
template Map14090(A...)
{
alias Map14090 = A[0];
}
template RoundRobin14090()
{
struct Empty;
alias RoundRobin14090 = Map14090!(Packed14090!(Empty));
}
alias roundRobin14090 = RoundRobin14090!();
/***************************************************/
// 13950
template Tuple13950(T...) { alias T Tuple13950; }
void f13950(int x = 0, Tuple13950!() xs = Tuple13950!())
{
assert(x == 0);
assert(xs.length == 0);
}
void test13950()
{
f13950();
}
/***************************************************/
int main()
{
test6475();
test6905();
test7019();
test7239();
test8123();
test8147();
test8410();
test8942();
test10142();
test11421();
test13950();
printf("Success\n");
return 0;
}