// EXTRA_SOURCES: imports/ufcs5a.d imports/ufcs5b.d imports/ufcs5c.d imports/ufcs5d.d imports/ufcs5e.d
module ufcs;
extern (C) int printf(const char*, ...);
/*******************************************/
struct S {}
int foo(int n) { return 1; }
int foo(int n, int m) { return 2; }
int goo(int[] a) { return 1; }
int goo(int[] a, int m) { return 2; }
int bar(S s) { return 1; }
int bar(S s, int n) { return 2; }
int baz(X)(X x) { return 1; }
int baz(X)(X x, int n) { return 2; }
int temp;
ref int boo(int n) { return temp; }
ref int coo(int[] a) { return temp; }
ref int mar(S s) { return temp; }
ref int maz(X)(X x) { return temp; }
void test1()
{
int n;
int[] a;
S s;
assert( foo(4) == 1); assert( baz(4) == 1);
assert( 4.foo() == 1); assert( 4.baz() == 1);
assert( 4.foo == 1); assert( 4.baz == 1);
assert( foo(4, 2) == 2); assert( baz(4, 2) == 2);
assert( 4.foo(2) == 2); assert( 4.baz(2) == 2);
assert((4.foo = 2) == 2); assert((4.baz = 2) == 2);
assert( goo(a) == 1); assert( baz(a) == 1);
assert( a.goo() == 1); assert( a.baz() == 1);
assert( a.goo == 1); assert( a.baz == 1);
assert( goo(a, 2) == 2); assert( baz(a, 2) == 2);
assert( a.goo(2) == 2); assert( a.baz(2) == 2);
assert((a.goo = 2) == 2); assert((a.baz = 2) == 2);
assert( bar(s) == 1); assert( baz(s) == 1);
assert( s.bar() == 1); assert( s.baz() == 1);
assert( s.bar == 1); assert( s.baz == 1);
assert( bar(s, 2) == 2); assert( baz(s, 2) == 2);
assert( s.bar(2) == 2); assert( s.baz(2) == 2);
assert((s.bar = 2) == 2); assert((s.baz = 2) == 2);
assert(( boo(4) = 2) == 2); assert(( maz(4) = 2) == 2);
assert((4.boo = 2) == 2); assert((4.maz = 2) == 2);
assert(( coo(a) = 2) == 2); assert(( maz(a) = 2) == 2);
assert((a.coo = 2) == 2); assert((a.maz = 2) == 2);
assert(( mar(s) = 2) == 2); assert(( maz(s) = 2) == 2);
assert((s.mar = 2) == 2); assert((s.maz = 2) == 2);
}
int hoo(T)(int n) { return 1; }
int hoo(T)(int n, int m) { return 2; }
int koo(T)(int[] a) { return 1; }
int koo(T)(int[] a, int m) { return 2; }
int var(T)(S s) { return 1; }
int var(T)(S s, int n) { return 2; }
int vaz(T, X)(X x) { return 1; }
int vaz(T, X)(X x, int n) { return 2; }
//int temp;
ref int voo(T)(int n) { return temp; }
ref int woo(T)(int[] a) { return temp; }
ref int nar(T)(S s) { return temp; }
ref int naz(T, X)(X x) { return temp; }
void test2()
{
int n;
int[] a;
S s;
assert( hoo!int(4) == 1); assert( vaz!int(4) == 1);
assert( 4.hoo!int() == 1); assert( 4.vaz!int() == 1);
assert( 4.hoo!int == 1); assert( 4.vaz!int == 1);
assert( hoo!int(4, 2) == 2); assert( vaz!int(4, 2) == 2);
assert( 4.hoo!int(2) == 2); assert( 4.vaz!int(2) == 2);
assert((4.hoo!int = 2) == 2); assert((4.vaz!int = 2) == 2);
assert( koo!int(a) == 1); assert( vaz!int(a) == 1);
assert( a.koo!int() == 1); assert( a.vaz!int() == 1);
assert( a.koo!int == 1); assert( a.vaz!int == 1);
assert( koo!int(a, 2) == 2); assert( vaz!int(a, 2) == 2);
assert( a.koo!int(2) == 2); assert( a.vaz!int(2) == 2);
assert((a.koo!int = 2) == 2); assert((a.vaz!int = 2) == 2);
assert( var!int(s) == 1); assert( vaz!int(s) == 1);
assert( s.var!int() == 1); assert( s.vaz!int() == 1);
assert( s.var!int == 1); assert( s.vaz!int == 1);
assert( var!int(s, 2) == 2); assert( vaz!int(s, 2) == 2);
assert( s.var!int(2) == 2); assert( s.vaz!int(2) == 2);
assert((s.var!int = 2) == 2); assert((s.vaz!int = 2) == 2);
assert(( voo!int(4) = 2) == 2); assert(( naz!int(4) = 2) == 2);
assert((4.voo!int = 2) == 2); assert((4.naz!int = 2) == 2);
assert(( woo!int(a) = 2) == 2); assert(( naz!int(a) = 2) == 2);
assert((a.woo!int = 2) == 2); assert((a.naz!int = 2) == 2);
assert(( nar!int(s) = 2) == 2); assert(( naz!int(s) = 2) == 2);
assert((s.nar!int = 2) == 2); assert((s.naz!int = 2) == 2);
}
/*******************************************/
auto init(T)(T val) { return 1; }
auto sort(alias fun, T)(T val) { return 1; }
@property auto max(alias fun, T)(T val) { return 1; }
@property auto infinity(alias opt, T)(T val) { return 1; }
void test3()
{
// See built-in 'init' property
assert(1 .init == 0);
assert([1] .init == null);
assert([1:1].init == null);
assert(1.0 .init is double.nan);
assert(10i .init is idouble.nan);
assert('c' .init == 0xFF);
assert("s" .init == null);
// x.init() has parens, so it runs UFCS call
assert( 1 .init() == 1);
assert([1] .init() == 1);
assert([1:1].init() == 1);
assert(1.0 .init() == 1);
assert(10i .init() == 1);
assert('c' .init() == 1);
assert("s" .init() == 1);
// x.init!YYY matches templatized UFCS call.
assert( 1 .init!int() == 1);
assert([1] .init!(int[])() == 1);
assert([1:1].init!(int[int])() == 1);
assert(1.0 .init!double() == 1);
assert(10i .init!idouble() == 1);
assert('c' .init!char() == 1);
assert("s" .init!string() == 1);
assert([1].sort!"a<b"() == 1);
// templatized properties runs UFCS call.
assert(1024.max!"a<b" == 1);
assert(1024.max == int.max);
assert(3.14.infinity!"+" == 1);
assert(3.14.infinity == (double).infinity);
}
/*******************************************/
template Signal4()
{
void connect(){}
}
struct S4
{
mixin Signal4!() s;
}
void test4()
{
S4 s;
s.s.connect(); // s.s is TOKdotexp, so never match UFCS
}
/*******************************************/
auto f5_1(int) { return 1; }
auto f5_2(string) { return 2; }
auto f5_3(double) { return 3; }
alias f5_4 = f5_1, f5_4 = f5_2;
alias f5_5 = f5_3, f5_5 = f5_4;
@property p5_1(int) { return 1; } @property p5_1(int, int) { return 1; }
@property p5_2(string) { return 2; } @property p5_2(string, int) { return 2; }
@property p5_3(double) { return 3; } @property p5_3(double, int) { return 3; }
alias p5_4 = p5_1, p5_4 = p5_2; alias p5_4 = p5_1, p5_4 = p5_2;
alias p5_5 = p5_3, p5_5 = p5_4; alias p5_5 = p5_3, p5_5 = p5_4;
// import overload set 'f5ov' and 'p5ov'
import imports.ufcs5b, imports.ufcs5c;
void test5()
{
{
// f5_1 .. f5_5 are symbols which declared in module scope
assert(100.f5_1() == 1);
assert("s".f5_2() == 2);
assert(1.4.f5_3() == 3);
assert(100.f5_4() == 1);
assert("s".f5_4() == 2);
assert(100.f5_5() == 1);
assert("s".f5_5() == 2);
assert(1.4.f5_5() == 3);
// overload set
assert(100.f5ov() == 1);
assert("s".f5ov() == 2);
// UFCS does not see function local alias
alias func5 = f5_1;
static assert(!__traits(compiles, { 1.func5(); }));
// property getter/setter
assert(100.p5_1 == 1); assert((100.p5_1 = 1) == 1);
assert("s".p5_2 == 2); assert(("s".p5_2 = 1) == 2);
assert(1.4.p5_3 == 3); assert((1.4.p5_3 = 1) == 3);
assert(100.p5_4 == 1); assert((100.p5_4 = 1) == 1);
assert("s".p5_4 == 2); assert(("s".p5_4 = 1) == 2);
assert(100.p5_5 == 1); assert((100.p5_5 = 1) == 1);
assert("s".p5_5 == 2); assert(("s".p5_5 = 1) == 2);
assert(1.4.p5_5 == 3); assert((1.4.p5_5 = 1) == 3);
// overload set ); assert(
assert(100.p5ov == 1); assert((100.p5ov = 1) == 1);
assert("s".p5ov == 2); assert(("s".p5ov = 1) == 2);
// local alias
alias prop5 = p5_1;
static assert(!__traits(compiles, { 1.prop5; }));
static assert(!__traits(compiles, { 1.prop5 = 1; }));
}
{
// f5a1 .. f5a5 are symbols which declared in module scope
import imports.ufcs5a;
// overload set 'f5ov' and 'p5ov'
import imports.ufcs5b, imports.ufcs5c;
assert(100.f5a1() == 1);
assert("s".f5a2() == 2);
assert(1.4.f5a3() == 3);
assert(100.f5a4() == 1);
assert("s".f5a4() == 2);
assert(100.f5a5() == 1);
assert("s".f5a5() == 2);
assert(1.4.f5a5() == 3);
assert(100.f5ov() == 1);
assert("s".f5ov() == 2);
assert(100.p5a1 == 1); assert((100.p5a1 = 1) == 1);
assert("s".p5a2 == 2); assert(("s".p5a2 = 1) == 2);
assert(1.4.p5a3 == 3); assert((1.4.p5a3 = 1) == 3);
assert(100.p5a4 == 1); assert((100.p5a4 = 1) == 1);
assert("s".p5a4 == 2); assert(("s".p5a4 = 1) == 2);
assert(100.p5a5 == 1); assert((100.p5a5 = 1) == 1);
assert("s".p5a5 == 2); assert(("s".p5a5 = 1) == 2);
assert(1.4.p5a5 == 3); assert((1.4.p5a5 = 1) == 3);
assert(100.p5ov == 1); assert((100.p5ov = 1) == 1);
assert("s".p5ov == 2); assert(("s".p5ov = 1) == 2);
}
{
// selective imports also work as expected
import imports.ufcs5a : f5a1, f5a2;
import imports.ufcs5a : p5a1, p5a2;
assert(100.f5a1() == 1);
assert("s".f5a2() == 2);
static assert(!__traits(compiles, { 1.4.f5a3(); }));
static assert(!__traits(compiles, { 100.f5a4(); }));
static assert(!__traits(compiles, { "s".f5a4(); }));
static assert(!__traits(compiles, { 100.f5a5(); }));
static assert(!__traits(compiles, { "s".f5a5(); }));
static assert(!__traits(compiles, { 1.4.f5a5(); }));
assert(100.p5a1 == 1); assert((100.p5a1 = 1) == 1);
assert("s".p5a2 == 2); assert(("s".p5a2 = 1) == 2);
static assert(!__traits(compiles, { 1.4.p5a3; }) && !__traits(compiles, { 1.4.p5a3 = 1; }));
static assert(!__traits(compiles, { 100.p5a4; }) && !__traits(compiles, { 100.p5a4 = 1; }));
static assert(!__traits(compiles, { "s".p5a4; }) && !__traits(compiles, { "s".p5a4 = 1; }));
static assert(!__traits(compiles, { 100.p5a5; }) && !__traits(compiles, { 100.p5a5 = 1; }));
static assert(!__traits(compiles, { "s".p5a5; }) && !__traits(compiles, { "s".p5a5 = 1; }));
static assert(!__traits(compiles, { 1.4.p5a5; }) && !__traits(compiles, { 1.4.p5a5 = 1; }));
}
{
// renamed imports also work as expected
import imports.ufcs5a : f5x1 = f5a1, f5x2 = f5a2;
import imports.ufcs5a : p5x1 = p5a1, p5x2 = p5a2;
assert(100.f5x1() == 1);
assert("s".f5x2() == 2);
static assert(!__traits(compiles, { 100.f5a1(); }));
static assert(!__traits(compiles, { "s".f5a2(); }));
static assert(!__traits(compiles, { 1.4.f5a3(); }));
static assert(!__traits(compiles, { 100.f5a4(); }));
static assert(!__traits(compiles, { "s".f5a4(); }));
static assert(!__traits(compiles, { 100.f5a5(); }));
static assert(!__traits(compiles, { "s".f5a5(); }));
static assert(!__traits(compiles, { 1.4.f5a5(); }));
assert(100.p5x1 == 1); assert((100.p5x1 = 1) == 1);
assert("s".p5x2 == 2); assert(("s".p5x2 = 1) == 2);
static assert(!__traits(compiles, { 100.p5a1; }) && !__traits(compiles, { 100.p5a1 = 1; }));
static assert(!__traits(compiles, { "s".p5a2; }) && !__traits(compiles, { "s".p5a2 = 1; }));
static assert(!__traits(compiles, { 1.4.p5a3; }) && !__traits(compiles, { 1.4.p5a3 = 1; }));
static assert(!__traits(compiles, { 100.p5a4; }) && !__traits(compiles, { 100.p5a4 = 1; }));
static assert(!__traits(compiles, { "s".p5a4; }) && !__traits(compiles, { "s".p5a4 = 1; }));
static assert(!__traits(compiles, { 100.p5a5; }) && !__traits(compiles, { 100.p5a5 = 1; }));
static assert(!__traits(compiles, { "s".p5a5; }) && !__traits(compiles, { "s".p5a5 = 1; }));
static assert(!__traits(compiles, { 1.4.p5a5; }) && !__traits(compiles, { 1.4.p5a5 = 1; }));
}
{
auto c5 = new C5();
foreach (name; __traits(allMembers, C5))
{
static if (name.length >= 4 && name[0..4] == "test")
{
mixin("c5."~name~"();"); // call test function
}
}
}
}
class B5
{
int g5bm(int) { return 0; }
static int g5bs(int) { return 0; }
}
class C5 : B5
{
// normal import works.
import imports.ufcs5a;
void test1()
{
assert(100.f5a1() == 1);
assert("s".f5a2() == 2);
assert(1.4.f5a3() == 3);
assert(100.f5a4() == 1);
assert("s".f5a4() == 2);
assert(100.f5a5() == 1);
assert("s".f5a5() == 2);
assert(1.4.f5a5() == 3);
assert(100.p5a1 == 1); assert((100.p5a1 = 1) == 1);
assert("s".p5a2 == 2); assert(("s".p5a2 = 1) == 2);
assert(1.4.p5a3 == 3); assert((1.4.p5a3 = 1) == 3);
assert(100.p5a4 == 1); assert((100.p5a4 = 1) == 1);
assert("s".p5a4 == 2); assert(("s".p5a4 = 1) == 2);
assert(100.p5a5 == 1); assert((100.p5a5 = 1) == 1);
assert("s".p5a5 == 2); assert(("s".p5a5 = 1) == 2);
assert(1.4.p5a5 == 3); assert((1.4.p5a5 = 1) == 3);
}
// selective imports also work as expected
import imports.ufcs5d : f5d1, f5d2;
import imports.ufcs5d : p5d1, p5d2;
void test2()
{
assert(100.f5d1() == 1);
assert("s".f5d2() == 2);
static assert(!__traits(compiles, { 1.4.f5d3(); }));
static assert(!__traits(compiles, { 100.f5d4(); }));
static assert(!__traits(compiles, { "s".f5d4(); }));
static assert(!__traits(compiles, { 100.f5d5(); }));
static assert(!__traits(compiles, { "s".f5d5(); }));
static assert(!__traits(compiles, { 1.4.f5d5(); }));
assert(100.p5d1 == 1); assert((100.p5d1 = 1) == 1);
assert("s".p5d2 == 2); assert(("s".p5d2 = 1) == 2);
static assert(!__traits(compiles, { 1.4.p5d3; }) && !__traits(compiles, { 1.4.p5d3 = 1; }));
static assert(!__traits(compiles, { 100.p5d4; }) && !__traits(compiles, { 100.p5d4 = 1; }));
static assert(!__traits(compiles, { "s".p5d4; }) && !__traits(compiles, { "s".p5d4 = 1; }));
static assert(!__traits(compiles, { 100.p5d5; }) && !__traits(compiles, { 100.p5d5 = 1; }));
static assert(!__traits(compiles, { "s".p5d5; }) && !__traits(compiles, { "s".p5d5 = 1; }));
static assert(!__traits(compiles, { 1.4.p5d5; }) && !__traits(compiles, { 1.4.p5d5 = 1; }));
}
// renamed imports also work as expected
import imports.ufcs5e : f5y1 = f5e1, f5y2 = f5e2;
import imports.ufcs5e : p5y1 = p5e1, p5y2 = p5e2;
void test3()
{
assert(100.f5y1() == 1);
assert("s".f5y2() == 2);
static assert(!__traits(compiles, { 100.f5e1(); }));
static assert(!__traits(compiles, { "s".f5e2(); }));
static assert(!__traits(compiles, { 1.4.f5e3(); }));
static assert(!__traits(compiles, { 100.f5e4(); }));
static assert(!__traits(compiles, { "s".f5e4(); }));
static assert(!__traits(compiles, { 100.f5e5(); }));
static assert(!__traits(compiles, { "s".f5e5(); }));
static assert(!__traits(compiles, { 1.4.f5e5(); }));
assert(100.p5y1 == 1); assert((100.p5y1 = 1) == 1);
assert("s".p5y2 == 2); assert(("s".p5y2 = 1) == 2);
static assert(!__traits(compiles, { 100.p5e1; }) && !__traits(compiles, { (100.p5e1 = 1); }));
static assert(!__traits(compiles, { "s".p5e2; }) && !__traits(compiles, { ("s".p5e2 = 1); }));
static assert(!__traits(compiles, { 1.4.p5e3; }) && !__traits(compiles, { (1.4.p5e3 = 1); }));
static assert(!__traits(compiles, { 100.p5e4; }) && !__traits(compiles, { (100.p5e4 = 1); }));
static assert(!__traits(compiles, { "s".p5e4; }) && !__traits(compiles, { ("s".p5e4 = 1); }));
static assert(!__traits(compiles, { 100.p5e5; }) && !__traits(compiles, { (100.p5e5 = 1); }));
static assert(!__traits(compiles, { "s".p5e5; }) && !__traits(compiles, { ("s".p5e5 = 1); }));
static assert(!__traits(compiles, { 1.4.p5e5; }) && !__traits(compiles, { (1.4.p5e5 = 1); }));
}
int g5cm(int) { return 0; }
static int g5cs(int) { return 0; }
void test4()
{
// UFCS does not see aggregate members
static assert(!__traits(compiles, { 1.g5cm(); }));
static assert(!__traits(compiles, { 1.g5cs(); }));
// Even if it is in base class
static assert(!__traits(compiles, { 1.g5bm(); }));
static assert(!__traits(compiles, { 1.g5bs(); }));
}
}
/*******************************************/
// 662
import std.stdio,std.string, std.conv;
enum Etest
{
a,b,c,d
}
//typedef int testi = 10;
//typedef Test Test2;
int test() { return 33; }
class Test
{
static int test(int i) { return i; }
}
int test(Etest test)
{
return cast(int)test;
}
//int test(testi i)
//{
// return cast(int)i;
//}
void test682()
{
assert(22.to!string() == "22");
assert((new Test).test(11) == 11);
assert(Test.test(11) == 11);
//assert(Test2.test(11) == 11);
assert(test() == 33);
assert(ufcs.test() == 33);
assert(Etest.d.test() == Etest.d);
//testi i;
//assert(i.test() == i.init);
}
/*******************************************/
// 3382
import std.range, std.algorithm;
@property T twice(T)(T x){ return x * x; }
real toreal(ireal x){ return x.im; }
char toupper(char c){ return ('a'<=c && c<='z') ? cast(char)(c - 'a' + 'A') : c; }
@property ref T setter(T)(ref T x, T v){ x = v; return x; }
void test3382()
{
auto r = iota(0, 10).map!"a*3"().filter!"a%2 != 0"();
foreach (e; r)
printf("e = %d\n", e);
assert(10.twice == 100);
assert(0.5.twice == 0.25);
assert(1.4i.toreal() == 1.4);
assert('c'.toupper() == 'C');
}
/*******************************************/
// 6185
void test6185()
{
import std.algorithm;
auto r1 = [1,2,3].map!"a*2";
assert(equal(r1, [2,4,6]));
auto r2 = r1.map!"a+2"();
assert(equal(r2, [4,6,8]));
}
/*******************************************/
// 6070
enum test6070a = ["test"].foo6070();
enum test6070b = foo6070(["test"]);
string foo6070(string[] s) { return ""; }
/*******************************************/
// 7670
struct A7670
{
double x;
}
@property ref double y7670(ref A7670 a)
{
return a.x;
}
void test7670()
{
A7670 a1;
a1.y7670() = 2.0; // OK
a1.y7670 = 2.0; // Error
}
/*******************************************/
// 7703
void f7703(T)(T a) { }
void test7703()
{
int x;
x.f7703; // accepted
x.f7703(); // accepted
x.f7703!int; // rejected -- "f(x) isn't a template"
x.f7703!int(); // accepted
}
/*******************************************/
// 7773
//import std.stdio;
void writeln7773(int n){}
void test7773()
{
(int.max).writeln7773(); // OK
int.max.writeln7773(); // error
}
/*******************************************/
// 7943
struct Foo7943
{
int _member;
alias _member this;
}
int foo7943(Foo7943 f) { return 1; }
int foo7943(int i) { return 2; }
void test7943()
{
Foo7943 f;
assert(f.foo7943() == 1);
}
/*******************************************/
// 8180
int writeln8180(T...)(T args) { return 1; }
struct Tuple8180(T...)
{
T field;
alias field this;
}
void test8180()
{
auto t = Tuple8180!(int)(10);
assert(t.writeln8180() == 1);
}
/*******************************************/
// 8245
string toStr8245(immutable(char)* p) { return null; }
@property string asStr8245(immutable(char)* p) { return null; }
void test8245()
{
immutable(char)* p = "foobar".ptr;
p.toStr8245();
p.asStr8245; // Error: no property 'asStr' for type 'immutable(char)'
}
/*******************************************/
// 8252
bool f(int x) { return !x; }
void test8252()
{
static assert(!1.f); // ok
static assert( 0.f); // fail
}
/*******************************************/
// 8453
T[] sort8453(T)(T[] a) { return a; }
void test8453()
{
int[int] foo;
auto bar1 = foo.keys().sort8453(); // OK
auto bar2 = foo.keys.sort8453(); // Error
}
/*******************************************/
// 8503
void α8503(int i) {}
void test8503()
{
0.α8503(); // Error
1.α8503(); // Error
}
/*******************************************/
// 9014
@property ref int foo9014(int[] a)
{
return a[0];
}
void test9014()
{
int[] bar;
static assert(!__traits(compiles, {
bar.foo9014 = missing.foo9014;
}));
}
/*******************************************/
// 9590
auto func9590(E)(lazy E expr) { }
int f9590a() { assert(0); }
void f9590b() { assert(0); }
void test9590()
{
func9590(f9590a()); // ok, no exceptions (lazy)
f9590a().func9590; // ok, no exceptions (lazy)
func9590(f9590b()); // ok, no exceptions (lazy)
f9590b().func9590; // L12: NG
}
/*******************************************/
// 9946
size_t count9946(alias x)(int[] haystack)
{
return 0;
}
void test9946()
{
int[] data;
auto n1 = count9946!5(data); // OK
auto n2 = data.count9946!5; // OK
auto a1 = new int[count9946!5(data)]; // OK
auto a2 = new int[data.count9946!5]; // Error
}
/*******************************************/
// 10618
template Temp10618(T)
{
size_t len = 1;
}
void test10618()
{
auto arr = new int[Temp10618!int.len];
assert(arr.length == 1);
}
/*******************************************/
// 10003
void foo10003(void *p) {}
void test10003()
{
void* p;
p.foo10003();
}
/*******************************************/
// 10041
auto writeln10041(T...)(T args) { return typeof(args[0]).stringof; }
void test10041()
{
auto aa = [1: 2];
assert(aa.writeln10041 == "int[int]");
assert(writeln10041(aa) == "int[int]");
}
/*******************************************/
// 10047
struct Typedef10047(T)
{
template opDispatch(string name)
{
static assert(0);
}
}
struct A10047 {}
int foo10047(Typedef10047!A10047 a) { return 10; }
void test10047()
{
Typedef10047!A10047 a;
assert(a.foo10047() == 10);
}
/*******************************************/
// 10166
auto foo10166()
{
0.bar10166!({})(0);
}
void bar10166(alias handler, T)(T t, int i)
{
t.bar10166!buzz10166(i);
}
void buzz10166() {}
/*******************************************/
// 10526
struct S10526
{
int opDispatch(string s, A...)(A args)
if (s[0..3] == "foo")
{
return 1;
}
}
int bar10526(X)(X) { return 2; }
int baz10526(T, X)(X) { return 3; }
void test10526()
{
S10526 s;
// with parenthesis
assert(s.foo10526() == 1);
assert(s.bar10526() == 2);
assert(s.baz10526!string() == 3);
// without parenthesis
assert(s.foo10526 == 1);
assert(s.bar10526 == 2);
assert(s.baz10526!string == 3);
}
/********************************************************/
// 10609
int foo10609(int x) { return x; }
void test10609()
{
int x = 1;
static assert(__traits(compiles, foo10609(x)));
static assert(__traits(compiles, 1.foo10609 ));
static assert(__traits(compiles, x.foo10609 ));
}
/*******************************************/
// 11312
struct S11312;
S11312* getS11312() { return null; }
int getValue(S11312*) { return 10; }
void test11312()
{
S11312* op = getS11312();
int x = op.getValue();
assert(x == 10);
}
/*******************************************/
// 15123
auto keys15123(K, V)(V[K] aa) { return [1]; }
auto values15123(K, V)(V[K] aa) { return [2]; }
alias id15123(alias arg) = arg;
enum int[int] aa15123 = [1:2];
static assert(id15123!(aa15123.keys15123) == [1]); // TypeIdentifier + UFCS
T[T] f15123(T)() { return [1:2]; }
static assert(id15123!(f15123!int.values15123) == [2]); // TypeInstance + UFCS
/*******************************************/
int main()
{
test1();
test2();
test3();
test4();
test5();
test682();
test3382();
test6185();
test7670();
test7703();
test7773();
test7943();
test8180();
test8245();
test8252();
test8453();
test8503();
test9014();
test9590();
test9946();
test10618();
test10003();
test10041();
test10047();
test10526();
test11312();
printf("Success\n");
return 0;
}