// PERMUTE_ARGS: -inline -O -property
// REQUIRED_ARGS: -dip25

// Test operator overloading

extern (C) int printf(const(char*) fmt, ...);

template Seq(T...){ alias T Seq; }

bool thrown(E, T)(lazy T val)
{
    try { val(); return false; }
    catch (E e) { return true; }
}

void stompStack() { int[256] sa = 0xdeadbeef; }

/**************************************/

class A
{
    string opUnary(string s)()
    {
        printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
        return s;
    }
}

void test1()
{
    auto a = new A();

    +a;
    -a;
    ~a;
    *a;
    ++a;
    --a;

    auto x = a++;
    assert(x == a);
    auto y = a--;
    assert(y == a);
}

/**************************************/

class A2
{
    T opCast(T)()
    {
        auto s = T.stringof;
        printf("A.opCast!(%.*s)\n", s.length, s.ptr);
        return T.init;
    }
}


void test2()
{
    auto a = new A2();

    auto x = cast(int)a;
    assert(x == 0);

    auto y = cast(char)a;
    assert(y == char.init);
}

/**************************************/

struct A3
{
    int opBinary(string s)(int i)
    {
        printf("A.opBinary!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    int opBinaryRight(string s)(int i) if (s == "/" || s == "*")
    {
        printf("A.opBinaryRight!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    T opCast(T)()
    {
        auto s = T.stringof;
        printf("A.opCast!(%.*s)\n", s.length, s.ptr);
        return T.init;
    }
}


void test3()
{
    A3 a;

    a + 3;
    4 * a;
    4 / a;
    a & 5;
}

/**************************************/

struct A4
{
    int opUnary(string s)()
    {
        printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    T opCast(T)()
    {
        auto s = T.stringof;
        printf("A.opCast!(%.*s)\n", s.length, s.ptr);
        return T.init;
    }
}


void test4()
{
    A4 a;

    if (a)
        int x = 3;
    if (!a)
        int x = 3;
    if (!!a)
        int x = 3;
}

/**************************************/

class A5
{
    override bool opEquals(Object o)
    {
        printf("A.opEquals!(%p)\n", o);
        return 1;
    }

    int opUnary(string s)()
    {
        printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    T opCast(T)()
    {
        auto s = T.stringof;
        printf("A.opCast!(%.*s)\n", s.length, s.ptr);
        return T.init;
    }
}

class B5 : A5
{
    override bool opEquals(Object o)
    {
        printf("B.opEquals!(%p)\n", o);
        return 1;
    }
}


void test5()
{
    A5 a = new A5();
    A5 a2 = new A5();
    B5 b = new B5();
    A n = null;

    if (a == a)
        int x = 3;
    if (a == a2)
        int x = 3;
    if (a == b)
        int x = 3;
    if (a == n)
        int x = 3;
    if (n == a)
        int x = 3;
    if (n == n)
        int x = 3;
}

/**************************************/

struct S6
{
    const bool opEquals(ref const S6 b)
    {
        printf("S.opEquals(S %p)\n", &b);
        return true;
    }

    const bool opEquals(ref const T6 b)
    {
        printf("S.opEquals(T %p)\n", &b);
        return true;
    }
}

struct T6
{
    const bool opEquals(ref const T6 b)
    {
        printf("T.opEquals(T %p)\n", &b);
        return true;
    }
/+
    const bool opEquals(ref const S6 b)
    {
        printf("T.opEquals(S %p)\n", &b);
        return true;
    }
+/
}


void test6()
{
    S6 s1;
    S6 s2;

    if (s1 == s2)
        int x = 3;

    T6 t;

    if (s1 == t)
        int x = 3;

    if (t == s2)
        int x = 3;
}

/**************************************/

struct S7
{
    const int opCmp(ref const S7 b)
    {
        printf("S.opCmp(S %p)\n", &b);
        return -1;
    }

    const int opCmp(ref const T7 b)
    {
        printf("S.opCmp(T %p)\n", &b);
        return -1;
    }
}

struct T7
{
    const int opCmp(ref const T7 b)
    {
        printf("T.opCmp(T %p)\n", &b);
        return -1;
    }
/+
    const int opCmp(ref const S7 b)
    {
        printf("T.opCmp(S %p)\n", &b);
        return -1;
    }
+/
}


void test7()
{
    S7 s1;
    S7 s2;

    if (s1 < s2)
        int x = 3;

    T7 t;

    if (s1 < t)
        int x = 3;

    if (t < s2)
        int x = 3;
}

/**************************************/

struct A8
{
    int opUnary(string s)()
    {
        printf("A.opUnary!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    int opIndexUnary(string s, T)(T i)
    {
        printf("A.opIndexUnary!(%.*s)(%d)\n", s.length, s.ptr, i);
        return 0;
    }

    int opIndexUnary(string s, T)(T i, T j)
    {
        printf("A.opIndexUnary!(%.*s)(%d, %d)\n", s.length, s.ptr, i, j);
        return 0;
    }

    int opSliceUnary(string s)()
    {
        printf("A.opSliceUnary!(%.*s)()\n", s.length, s.ptr);
        return 0;
    }

    int opSliceUnary(string s, T)(T i, T j)
    {
        printf("A.opSliceUnary!(%.*s)(%d, %d)\n", s.length, s.ptr, i, j);
        return 0;
    }
}


void test8()
{
    A8 a;

    -a;
    -a[3];
    -a[3, 4];
    -a[];
    -a[5 .. 6];
    --a[3];
}

/**************************************/

struct A9
{
    int opOpAssign(string s)(int i)
    {
        printf("A.opOpAssign!(%.*s)\n", s.length, s.ptr);
        return 0;
    }

    int opIndexOpAssign(string s, T)(int v, T i)
    {
        printf("A.opIndexOpAssign!(%.*s)(%d, %d)\n", s.length, s.ptr, v, i);
        return 0;
    }

    int opIndexOpAssign(string s, T)(int v, T i, T j)
    {
        printf("A.opIndexOpAssign!(%.*s)(%d, %d, %d)\n", s.length, s.ptr, v, i, j);
        return 0;
    }

    int opSliceOpAssign(string s)(int v)
    {
        printf("A.opSliceOpAssign!(%.*s)(%d)\n", s.length, s.ptr, v);
        return 0;
    }

    int opSliceOpAssign(string s, T)(int v, T i, T j)
    {
        printf("A.opSliceOpAssign!(%.*s)(%d, %d, %d)\n", s.length, s.ptr, v, i, j);
        return 0;
    }
}


void test9()
{
    A9 a;

    a += 8;
    a -= 8;
    a *= 8;
    a /= 8;
    a %= 8;
    a &= 8;
    a |= 8;
    a ^= 8;
    a <<= 8;
    a >>= 8;
    a >>>= 8;
    a ~= 8;
    a ^^= 8;

    a[3] += 8;
    a[3] -= 8;
    a[3] *= 8;
    a[3] /= 8;
    a[3] %= 8;
    a[3] &= 8;
    a[3] |= 8;
    a[3] ^= 8;
    a[3] <<= 8;
    a[3] >>= 8;
    a[3] >>>= 8;
    a[3] ~= 8;
    a[3] ^^= 8;

    a[3, 4] += 8;
    a[] += 8;
    a[5 .. 6] += 8;
}

/**************************************/

struct BigInt
{
    int opEquals(T)(T n) const
    {
        return 1;
    }

    int opEquals(T:int)(T n) const
    {
        return 1;
    }

    int opEquals(T:const(BigInt))(T n) const
    {
        return 1;
    }

}

int decimal(BigInt b, const BigInt c)
{
    while (b != c) {
    }
    return 1;
}

/**************************************/

struct Foo10
{
    int opUnary(string op)() { return 1; }
}

void test10()
{
    Foo10 foo;
    foo++;
}

/**************************************/

struct S4913
{
    bool opCast(T : bool)() { return true; }
}

int bug4913()
{
    if (S4913 s = S4913()) { return 83; }
    return 9;
}

static assert(bug4913() == 83);

/**************************************/
// 5551

struct Foo11 {
    Foo11 opUnary(string op:"++")() {
        return this;
    }
    Foo11 opBinary(string op)(int y) {
        return this;
    }
}

void test11()
{
    auto f = Foo11();
    f++;
}

/**************************************/
// 4099

struct X4099
{
    int x;
    alias x this;

    typeof(this) opUnary (string operator) ()
    {
        printf("operator called\n");
        return this;
    }
}

void test4099()
{
    X4099 x;
    X4099 r1 = ++x; //operator called
    X4099 r2 = x++; //BUG! (alias this used. returns int)
}

/**************************************/

void test12()
{
    static int opeq;

    // xopEquals OK
    static struct S1a { const bool opEquals(    const typeof(this) rhs) { ++opeq; return false; } }
    static struct S1b { const bool opEquals(ref const typeof(this) rhs) { ++opeq; return false; } }
    static struct S1c { const bool opEquals(          typeof(this) rhs) { ++opeq; return false; } }

    // xopEquals NG
    static struct S2a {       bool opEquals(          typeof(this) rhs) { ++opeq; return false; } }

    foreach (S; Seq!(S1a, S1b, S1c))
    {
        S s;
        opeq = 0;
        assert(s != s);                     // call opEquals directly
        assert(!typeid(S).equals(&s, &s));  // -> xopEquals (-> __xopEquals) -> opEquals
        assert(opeq == 2);
    }

    foreach (S; Seq!(S2a))
    {
        S s;
        opeq = 0;
        assert(s != s);
        assert(thrown!Error(!typeid(S).equals(&s, &s)));
            // Error("notImplemented") thrown
        assert(opeq == 1);
    }
}

/**************************************/

void test13()
{
    static int opeq;

    struct X
    {
        const bool opEquals(const X){ ++opeq; return false; }
    }
    struct S
    {
        X x;
    }

    S makeS(){ return S(); }

    S s;
    opeq = 0;
    assert(s != s);
    assert(makeS() != s);
    assert(s != makeS());
    assert(makeS() != makeS());
    assert(opeq == 4);

    // built-in opEquals == const bool opEquals(const S rhs);
    assert(s != s);
    assert(opeq == 5);

    // xopEquals
    assert(!typeid(S).equals(&s, &s));
    assert(opeq == 6);
}

/**************************************/

void test14()
{
    static int opeq;

    struct S
    {
        const bool opEquals(T)(const T rhs) { ++opeq; return false; }
    }

    S makeS(){ return S(); }

    S s;
    opeq = 0;
    assert(s != s);
    assert(makeS() != s);
    assert(s != makeS());
    assert(makeS() != makeS());
    assert(opeq == 4);

    // xopEquals (-> __xxopEquals) -> template opEquals
    assert(!typeid(S).equals(&s, &s));
    assert(opeq == 5);
}

/**************************************/

void test15()
{
    struct S
    {
        const bool opEquals(T)(const(T) rhs)
        if (!is(T == S))
        { return false; }

        @disable const bool opEquals(T)(const(T) rhs)
        if (is(T == S))
        { return false; }
    }

    S makeS(){ return S(); }

    S s;
    static assert(!__traits(compiles, s != s));
    static assert(!__traits(compiles, makeS() != s));
    static assert(!__traits(compiles, s != makeS()));
    static assert(!__traits(compiles, makeS() != makeS()));

    // xopEquals (-> __xxopEquals) -> Error thrown
    assert(thrown!Error(!typeid(S).equals(&s, &s)));
}

/**************************************/

void test16()
{
    struct X
    {
        int n;
        const bool opEquals(T)(T t)
        {
            return false;
        }
    }
    struct S
    {
        X x;
    }

    S s1, s2;
    assert(s1 != s2);
        // field template opEquals should call
}

/**************************************/

void test17()
{
    static int opeq = 0;

    struct S
    {
        bool opEquals(ref S rhs) { ++opeq; return false; }
    }
    S[] sa1 = new S[3];
    S[] sa2 = new S[3];
    assert(sa1 != sa2);     // isn't used TypeInfo.equals
    assert(opeq == 1);

    const(S)[] csa = new const(S)[3];
    static assert(!__traits(compiles, csa == sa1));
    static assert(!__traits(compiles, sa1 == csa));
    static assert(!__traits(compiles, csa == csa));
}

/**************************************/
// 3789

bool test3789()
{
    static struct Float
    {
        double x;
    }
    Float f;
    assert(f.x != f.x); // NaN != NaN
    assert(f != f);

    static struct Array
    {
        int[] x;
    }
    Array a1 = Array([1,2,3].dup);
    Array a2 = Array([1,2,3].dup);
    if (!__ctfe)
    {   // Currently doesn't work this in CTFE - may or may not a bug.
        assert(a1.x !is a2.x);
    }
    assert(a1.x == a2.x);
    assert(a1 == a2);

    static struct AA
    {
        int[int] x;
    }
    AA aa1 = AA([1:1,2:2,3:3]);
    AA aa2 = AA([1:1,2:2,3:3]);
    if (!__ctfe)
    {   // Currently doesn't work this in CTFE - may or may not a bug.
        assert(aa1.x !is aa2.x);
    }
    if (!__ctfe)
    {   // This is definitely a bug. Should work in CTFE.
        assert(aa1.x == aa2.x);
        assert(aa1 == aa2);
    }

    if (!__ctfe)
    {   // Currently union operation is not supported in CTFE.
        union U1
        {
            double x;
        }
        static struct UnionA
        {
            int[] a;
            U1 u;
        }
        auto ua1 = UnionA([1,2,3]);
        auto ua2 = UnionA([1,2,3]);
        assert(ua1.u.x is ua2.u.x);
        assert(ua1.u.x != ua2.u.x);
        assert(ua1 == ua2);
        ua1.u.x = 1.0;
        ua2.u.x = 1.0;
        assert(ua1.u.x is ua2.u.x);
        assert(ua1.u.x == ua2.u.x);
        assert(ua1 == ua2);
        ua1.u.x = double.nan;
        assert(ua1.u.x !is ua2.u.x);
        assert(ua1.u.x !=  ua2.u.x);
        assert(ua1 != ua2);

        union U2
        {
            int[] a;
        }
        static struct UnionB
        {
            double x;
            U2 u;
        }
        auto ub1 = UnionB(1.0);
        auto ub2 = UnionB(1.0);
        assert(ub1 == ub2);
        ub1.u.a = [1,2,3].dup;
        ub2.u.a = [1,2,3].dup;
        assert(ub1.u.a !is ub2.u.a);
        assert(ub1.u.a  == ub2.u.a);
        assert(ub1 != ub2);
        ub2.u.a = ub1.u.a;
        assert(ub1.u.a is ub2.u.a);
        assert(ub1.u.a == ub2.u.a);
        assert(ub1 == ub2);
    }

    if (!__ctfe)
    {   // This is definitely a bug. Should work in CTFE.
        static struct Class
        {
            Object x;
        }
        static class X
        {
            override bool opEquals(Object o){ return true; }
        }

        Class c1a = Class(new Object());
        Class c2a = Class(new Object());
        assert(c1a.x !is c2a.x);
        assert(c1a.x != c2a.x);
        assert(c1a != c2a); // Pass, Object.opEquals works like bitwise compare

        Class c1b = Class(new X());
        Class c2b = Class(new X());
        assert(c1b.x !is c2b.x);
        assert(c1b.x == c2b.x);
        assert(c1b == c2b); // Fails, should pass
    }
    return true;
}
static assert(test3789());

/**************************************/
// 10037

struct S10037
{
    bool opEquals(ref const S10037) { assert(0); }
}

struct T10037
{
    S10037 s;
    // Compiler should not generate 'opEquals' here implicitly:
}

struct Sub10037(TL...)
{
    TL data;
    int value;
    alias value this;
}

void test10037()
{
    S10037 s;
    T10037 t;
    static assert( __traits(hasMember, S10037, "opEquals"));
    static assert(!__traits(hasMember, T10037, "opEquals"));
    assert(thrown!Error(s == s));
    assert(thrown!Error(t == t));

    Sub10037!(S10037) lhs;
    Sub10037!(S10037) rhs;
    static assert(!__traits(hasMember, Sub10037!(S10037), "opEquals"));
    assert(lhs == rhs);     // lowered to: lhs.value == rhs.value
}

/**************************************/
// 5810

struct Bug5810
{
    void opUnary(string op)() {}
}

struct Foo5810
{
    Bug5810 x;
    void bar() { x++; }
}

/**************************************/
// 6798

struct Tuple6798(T...)
{
    T field;
    alias field this;

    bool opEquals(Tuple6798 rhs)
    {
        foreach (i, _; T)
        {
            if (this[i] != rhs[i])
                return false;
        }
        return true;
    }
}
auto tuple6798(T...)(T args)
{
    return Tuple6798!T(args);
}

int test6798a()
{
    //import std.typecons;
    alias tuple6798 tuple;

    static struct S1
    {
        auto opDollar(size_t dim)()
        {
            return 99;
        }
        auto opSlice(int dim)(int lwr, int upr)
        {
            return [dim, lwr, upr];
        }

        auto opIndex(A...)(A indices)
        {
            return tuple(" []", indices);
        }
        auto opIndexUnary(string op, A...)(A indices)
        {
            return tuple(op~"[]", indices);
        }
        auto opIndexAssign(A...)(string s, A indices)
        {
            return tuple("[] =", s, indices);
        }
        auto opIndexOpAssign(string op, A...)(string s, A indices)
        {
            return tuple("[]"~op~"=", s, indices);
        }
    }
    S1 s1;
    assert( s1[]       == tuple(" []"));
    assert( s1[10]     == tuple(" []", 10));
    assert( s1[10, 20] == tuple(" []", 10, 20));
    assert( s1[10..20] == tuple(" []", [0, 10, 20]));
    assert(+s1[]       == tuple("+[]"));
    assert(-s1[10]     == tuple("-[]", 10));
    assert(*s1[10, 20] == tuple("*[]", 10, 20));
    assert(~s1[10..20] == tuple("~[]", [0, 10, 20]));
    assert((s1[]       ="x") == tuple("[] =", "x"));
    assert((s1[10]     ="x") == tuple("[] =", "x", 10));
    assert((s1[10, 20] ="x") == tuple("[] =", "x", 10, 20));
    assert((s1[10..20] ="x") == tuple("[] =", "x", [0, 10, 20]));
    assert((s1[]      +="x") == tuple("[]+=", "x"));
    assert((s1[10]    -="x") == tuple("[]-=", "x", 10));
    assert((s1[10, 20]*="x") == tuple("[]*=", "x", 10, 20));
    assert((s1[10..20]~="x") == tuple("[]~=", "x", [0, 10, 20]));
    assert( s1[20..30, 10]           == tuple(" []", [0, 20, 30], 10));
    assert( s1[10, 10..$, $-4, $..2] == tuple(" []", 10, [1,10,99], 99-4, [3,99,2]));
    assert(+s1[20..30, 10]           == tuple("+[]", [0, 20, 30], 10));
    assert(-s1[10, 10..$, $-4, $..2] == tuple("-[]", 10, [1,10,99], 99-4, [3,99,2]));
    assert((s1[20..30, 10]           ="x") == tuple("[] =", "x", [0, 20, 30], 10));
    assert((s1[10, 10..$, $-4, $..2] ="x") == tuple("[] =", "x", 10, [1,10,99], 99-4, [3,99,2]));
    assert((s1[20..30, 10]          +="x") == tuple("[]+=", "x", [0, 20, 30], 10));
    assert((s1[10, 10..$, $-4, $..2]-="x") == tuple("[]-=", "x", 10, [1,10,99], 99-4, [3,99,2]));

    // opIndex exist, but opSlice for multi-dimensional doesn't.
    static struct S2
    {
        auto opSlice(size_t dim)() { return [dim]; }
        auto opSlice()(size_t lwr, size_t upr) { return [lwr, upr]; }

        auto opIndex(A...)(A indices){ return [[indices]]; }
    }
    S2 s2;
    assert(s2[] == [[]]);
    assert(s2[1] == [[1]]);
    assert(s2[1, 2] == [[1, 2]]);
    assert(s2[1..2] == [1, 2]);
    static assert(!__traits(compiles, s2[1, 2..3] ));
    static assert(!__traits(compiles, s2[1..2, 2..3] ));

    // opSlice for multi-dimensional exists, but opIndex for that doesn't.
    static struct S3
    {
        auto opSlice(size_t dim)(size_t lwr, size_t upr) { return [lwr, upr]; }

        auto opIndex(size_t n){ return [[n]]; }
        auto opIndex(size_t n, size_t m){ return [[n, m]]; }
    }
    S3 s3;
    static assert(!__traits(compiles, s3[] ));
    assert(s3[1]    == [[1]]);
    assert(s3[1, 2] == [[1, 2]]);
    static assert(!__traits(compiles, s3[1..2] ));
    static assert(!__traits(compiles, s3[1, 2..3] ));
    static assert(!__traits(compiles, s3[1..2, 2..3] ));

    return 0;
}

int test6798b()
{
    static struct Typedef(T)
    {
        private T Typedef_payload = T.init;

        alias a = Typedef_payload;

        auto ref opIndex(this X, D...)(auto ref D i)    { return a[i]; }
        auto ref opSlice(this X      )()                { return a[]; }
        auto ref opSlice(this X, B, E)(auto ref B b, auto ref E e)
        {
            assert(b == 0 && e == 3);
            return a[b..e];
        }

        template opDispatch(string name)
        {
            // field or property function
            @property auto ref opDispatch(this X)()                { return mixin("a."~name);        }
            @property auto ref opDispatch(this X, V)(auto ref V v) { return mixin("a."~name~" = v"); }
        }

        static if (is(typeof(a) : E[], E))
        {
            auto opDollar() const { return a.length; }
        }
    }

    Typedef!(int[]) dollar2;
    dollar2.length = 3;
    assert(dollar2.Typedef_payload.length == 3);
    assert(dollar2[0 .. $] is dollar2[0 .. 3]);

    return 0;
}

int test6798c()
{
    alias T = Tuple6798!(int, int);
    auto n = T[].init;
    static assert(is(typeof(n[0]) == Tuple6798!(int, int)));

    return 0;
}

void test6798()
{
    static assert(test6798a() == 0);    // CTFE check
    test6798a();
    static assert(test6798b() == 0);
    test6798b();
    static assert(test6798c() == 0);
    test6798c();
}

/**************************************/
// 12382

struct S12382
{
    size_t opDollar() { return 0; }
    size_t opIndex(size_t) { return 0; }
}

S12382 func12382() { return S12382(); }

static assert(S12382.init[$] == 0);
static assert(func12382()[$] == 0);
enum e12382a = S12382.init[$];
enum e12382b = func12382()[$];
static v12382a = S12382.init[$];
static v12382b = func12382()[$];

void test12382()
{
    static assert(S12382.init[$] == 0);
    static assert(func12382()[$] == 0);
    enum e12382a = S12382.init[$];
    enum e12382b = func12382()[$];
    static v12382a = S12382.init[$];
    static v12382b = func12382()[$];
}

/**************************************/
// 12904

struct S12904
{
    void opIndexAssign(U, A...)(U value, A args)
    {
        static assert(0);
    }
    void opSliceAssign(int n)
    {
        assert(n == 10);
    }

    size_t opDollar(size_t dim)()
    {
        return 7;
    }

    int opSlice(size_t dim)(size_t, size_t to)
    {
        assert(to == 7);
        return 1;
    }

    int opIndex(int i1, int i2)
    {
        assert(i1 == 1 && i2 == 1);
        return 10;
    }
}

void test12904()
{
    S12904 s;
    s[] = s[0..$, 1];
    s[] = s[0..$, 0..$];
}

/**************************************/
// 7641

mixin template Proxy7641(alias a)
{
    auto ref opBinaryRight(string op, B)(auto ref B b)
    {
        return mixin("b "~op~" a");
    }
}
struct Typedef7641(T)
{
    private T Typedef_payload;

    this(T init)
    {
        Typedef_payload = init;
    }

    mixin Proxy7641!Typedef_payload;
}

void test7641()
{
    class C {}
    C c1 = new C();
    auto a = Typedef7641!C(c1);
    static assert(!__traits(compiles, { C c2 = a; }));
}

/**************************************/
// 8434

void test8434()
{
    static class Vector2D(T)
    {
        T x, y;

        this(T x, T y) {
            this.x = x;
            this.y = y;
        }

        U opCast(U)() const { assert(0); }
    }

    alias Vector2D!(short) Vector2s;
    alias Vector2D!(float) Vector2f;

    Vector2s vs1 = new Vector2s(42, 23);
    Vector2s vs2 = new Vector2s(42, 23);

    assert(vs1 != vs2);
}

/**************************************/

void test18()
{
    // one dimensional indexing
    static struct IndexExp
    {
        int[] opIndex(int a)
        {
            return [a];
        }

        int[] opIndexUnary(string op)(int a)
        {
            return [a];
        }

        int[] opIndexAssign(int val, int a)
        {
            return [val, a];
        }

        int[] opIndexOpAssign(string op)(int val, int a)
        {
            return [val, a];
        }

        int opDollar()
        {
            return 8;
        }
    }

    IndexExp index;
    // opIndex
    assert(index[8]     == [8]);
    assert(index[$]     == [8]);
    assert(index[$-1]   == [7]);
    assert(index[$-$/2] == [4]);
    // opIndexUnary
    assert(-index[8]     == [8]);
    assert(-index[$]     == [8]);
    assert(-index[$-1]   == [7]);
    assert(-index[$-$/2] == [4]);
    // opIndexAssign
    assert((index[8]     = 2) == [2, 8]);
    assert((index[$]     = 2) == [2, 8]);
    assert((index[$-1]   = 2) == [2, 7]);
    assert((index[$-$/2] = 2) == [2, 4]);
    // opIndexOpAssign
    assert((index[8]     += 2) == [2, 8]);
    assert((index[$]     += 2) == [2, 8]);
    assert((index[$-1]   += 2) == [2, 7]);
    assert((index[$-$/2] += 2) == [2, 4]);

    // opDollar is only one-dimensional
    static assert(!is(typeof(index[$, $])));
    static assert(!is(typeof(-index[$, $])));
    static assert(!is(typeof(index[$, $] = 2)));
    static assert(!is(typeof(index[$, $] += 2)));

    // multi dimensional indexing
    static struct ArrayExp
    {
        int[] opIndex(int a, int b)
        {
            return [a, b];
        }

        int[] opIndexUnary(string op)(int a, int b)
        {
            return [a, b];
        }

        int[] opIndexAssign(int val, int a, int b)
        {
            return [val, a, b];
        }

        int[] opIndexOpAssign(string op)(int val, int a, int b)
        {
            return [val, a, b];
        }

        int opDollar(int dim)()
        {
            return dim;
        }
    }

    ArrayExp array;
    // opIndex
    assert(array[8, 8]     == [8, 8]);
    assert(array[$, $]     == [0, 1]);
    assert(array[$, $-1]   == [0, 0]);
    assert(array[2, $-$/2] == [2, 1]);
    // opIndexUnary
    assert(-array[8, 8]     == [8, 8]);
    assert(-array[$, $]     == [0, 1]);
    assert(-array[$, $-1]   == [0, 0]);
    assert(-array[2, $-$/2] == [2, 1]);
    // opIndexAssign
    assert((array[8, 8]      = 2) == [2, 8, 8]);
    assert((array[$, $]      = 2) == [2, 0, 1]);
    assert((array[$, $-1]    = 2) == [2, 0, 0]);
    assert((array[2, $-$/2]  = 2) == [2, 2, 1]);
    // opIndexOpAssign
    assert((array[8, 8]      += 2) == [2, 8, 8]);
    assert((array[$, $]      += 2) == [2, 0, 1]);
    assert((array[$, $-1]    += 2) == [2, 0, 0]);
    assert((array[2, $-$/2]  += 2) == [2, 2, 1]);

    // one dimensional slicing
    static struct SliceExp
    {
        int[] opSlice(int a, int b)
        {
            return [a, b];
        }

        int[] opSliceUnary(string op)(int a, int b)
        {
            return [a, b];
        }

        int[] opSliceAssign(int val, int a, int b)
        {
            return [val, a, b];
        }

        int[] opSliceOpAssign(string op)(int val, int a, int b)
        {
            return [val, a, b];
        }

        int opDollar()
        {
            return 8;
        }
    }

    SliceExp slice;
    // opSlice
    assert(slice[0 .. 8]     == [0, 8]);
    assert(slice[0 .. $]     == [0, 8]);
    assert(slice[0 .. $-1]   == [0, 7]);
    assert(slice[$-3 .. $-1] == [5, 7]);
    // opSliceUnary
    assert(-slice[0 .. 8]     == [0, 8]);
    assert(-slice[0 .. $]     == [0, 8]);
    assert(-slice[0 .. $-1]   == [0, 7]);
    assert(-slice[$-3 .. $-1] == [5, 7]);
    // opSliceAssign
    assert((slice[0 .. 8]     = 2) == [2, 0, 8]);
    assert((slice[0 .. $]     = 2) == [2, 0, 8]);
    assert((slice[0 .. $-1]   = 2) == [2, 0, 7]);
    assert((slice[$-3 .. $-1] = 2) == [2, 5, 7]);
    // opSliceOpAssign
    assert((slice[0 .. 8]     += 2) == [2, 0, 8]);
    assert((slice[0 .. $]     += 2) == [2, 0, 8]);
    assert((slice[0 .. $-1]   += 2) == [2, 0, 7]);
    assert((slice[$-3 .. $-1] += 2) == [2, 5, 7]);

    // test different kinds of opDollar
    auto dollar(string opDollar)()
    {
        static struct Dollar
        {
            size_t opIndex(size_t a) { return a; }
            mixin(opDollar);
        }
        Dollar d;
        return d[$];
    }
    assert(dollar!q{@property size_t opDollar() { return 8; }}() == 8);
    assert(dollar!q{template opDollar(size_t dim) { enum opDollar = dim; }}() == 0);
    assert(dollar!q{static const size_t opDollar = 8;}() == 8);
    assert(dollar!q{enum opDollar = 8;}() == 8);
    assert(dollar!q{size_t length() { return 8; } alias length opDollar;}() == 8);
}

/**************************************/

void test19()
{
    static struct Foo
    {
        int[] opSlice(int a, int b)
        {
            return [a, b];
        }

        int opDollar(int dim)()
        {
            return dim;
        }
    }

    Foo foo;
    assert(foo[0 .. $] == [0, 0]);
}

/**************************************/
// 9453

struct Foo9453
{
    static int ctor = 0;

    this(string bar) { ++ctor; }

    void opIndex(size_t i) const {}
    void opSlice(size_t s, size_t e) const {}

    size_t opDollar(int dim)() const if (dim == 0) { return 1; }
}

void test9453()
{
    assert(Foo9453.ctor == 0);  Foo9453("bar")[$-1];
    assert(Foo9453.ctor == 1);  Foo9453("bar")[0..$];
    assert(Foo9453.ctor == 2);
}

/**************************************/
// 9496

struct S9496
{
    static S9496* ptr;

    size_t opDollar()
    {
        assert(ptr is &this);
        return 10;
    }
    void opSlice(size_t , size_t)
    {
        assert(ptr is &this);
    }
    void getSlice()
    {
        assert(ptr is &this);
        this[1 .. opDollar()];
        this[1 .. $];
    }
}

void test9496()
{
    S9496 s;
    S9496.ptr = &s;
    s.getSlice();
    s[1 .. $];
}

/**************************************/
// 9689

struct B9689(T)
{
    T val;
    @disable this(this);

    bool opEquals(this X, B)(auto ref B b)
    {
        //pragma(msg, "+", X, ", B = ", B, ", ref = ", __traits(isRef, b));
        return this.val == b.val;
        //pragma(msg, "-", X, ", B = ", B, ", ref = ", __traits(isRef, b));
    }
}

struct S9689
{
    B9689!int num;
}

void test9689()
{
    B9689!S9689 b;
}

/**************************************/
// 9694

struct S9694
{
    bool opEquals(ref S9694 rhs)
    {
        assert(0);
    }
}
struct T9694
{
    S9694 s;
}
void test9694()
{
    T9694 t;
    assert(thrown!Error(typeid(T9694).equals(&t, &t)));
}

/**************************************/
// 10064

void test10064()
{
    static struct S
    {
        int x = 3;

        @disable this();

        this(int)
        { x = 7; }

        int opSlice(size_t, size_t)
        { return 0; }

        @property size_t opDollar()
        {
            assert(x == 7 || x == 3); // fails
            assert(x == 7);
            return 0;
        }
    }
    auto x = S(0)[0 .. $];
}

/**************************************/
// 12585

void test12585()
{
    struct Bar
    {
        int opIndex(size_t index)
        {
            return 0;
        }
    }

    struct Foo
    {
        Bar opIndex(size_t index)
        {
            throw new Exception("Fail");
        }
    }

    Foo foo()
    {
        return Foo();
    }

    void catchStuff(E)(lazy E expression)
    {
        try
            expression();
        catch (Exception e) {}
    }

    catchStuff(foo()[0][0]);          // OK <- NG
    catchStuff(foo().opIndex(0)[0]);  // OK
    catchStuff(foo()[0].opIndex(0));  // OK
    Foo f; catchStuff(f[0][0]);       // OK
}

/**************************************/
// 10394

void test10394()
{
    alias Seq!(int, int) Pair;
    Pair pair;

    struct S1
    {
        int opBinary(string op)(Pair) { return 1;  }
        bool opEquals(Pair) { return true; }
        int opOpAssign(string op)(Pair) { return 1; }
    }
    S1 s1;
    assert((s1 + pair) == 1);
    assert((s1 == pair) == true);
    assert((s1 *= pair) == 1);

    struct S2
    {
        int opBinaryRight(string op)(Pair lhs) { return 1;  }
        int opCmp(Pair) { return -1; }
    }
    S2 s2;
    assert((pair in s2) == 1);
    assert(s2 < pair);
}

/**************************************/
// 10597

struct R10597
{
    void opIndex(int) {}
    void opSlice(int, int) {}
    int opDollar();
}
R10597 r;

struct S10597
{
    static assert(is(typeof(r[0]))); //ok
    static assert(is(typeof(r[$]))); //fails

    static assert(is(typeof(r[0..0]))); //ok
    static assert(is(typeof(r[$..$]))); //fails

    void foo()
    {
        static assert(is(typeof(r[0]))); //ok
        static assert(is(typeof(r[$]))); //ok

        static assert(is(typeof(r[0..0]))); //ok
        static assert(is(typeof(r[$..$]))); //ok
    }
}

static assert(is(typeof(r[0]))); //ok
static assert(is(typeof(r[$]))); //fails

static assert(is(typeof(r[0..0]))); //ok
static assert(is(typeof(r[$..$]))); //fails

void test10597()
{
    static assert(is(typeof(r[0]))); //ok
    static assert(is(typeof(r[$]))); //ok

    static assert(is(typeof(r[0..0]))); //ok
    static assert(is(typeof(r[$..$]))); //ok
}

/**************************************/
// 10567

// doesn't require thunk
struct S10567x1n { int value; int opCmp(ref const S10567x1n rhs) const { return 0; } }

// requires thunk
struct S10567y1n { int value; int opCmp(const S10567y1n rhs) const { return 0; } }
struct S10567y1t { int value; int opCmp(S)(const S rhs) const { return 0; } }

// doesn't support const comparison
struct S10567z1n { int value; int opCmp(const S10567z1n rhs) { return 0; } }
struct S10567z1t { int value; int opCmp(S)(const S rhs) { return 0; } }

/+
struct S10567x2n { S10567x1n s; this(int n) { s = typeof(s)(n); } alias s this; }

struct S10567y2n { S10567y1n s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567y2t { S10567y1t s; this(int n) { s = typeof(s)(n); } alias s this; }

struct S10567z2n { S10567z1n s; this(int n) { s = typeof(s)(n); } alias s this; }
struct S10567z2t { S10567z1t s; this(int n) { s = typeof(s)(n); } alias s this; }

struct S10567d1
{
    int value;
    int opDispatch(string name, S)(const S rhs) const if (name == "opCmp")
    { assert(0); }
}
struct S10567d2
{
    int value;
    template opDispatch(string name) if (name == "opCmp")
    {
        int opDispatch(const S rhs) const
        { assert(0); }
    }
}

// recursive alias this + opCmp searching
struct S10567r1
{
    static S10567r2 t;
    ref S10567r2 payload() { return t; }
    alias payload this;

    int opCmp(const S10567r1 s) const { return 0; }
}
struct S10567r2
{
    static S10567r1 s;
    ref S10567r1 payload() { return s; }
    alias payload this;
}
+/

void test10567()
{
    foreach (S; Seq!(S10567x1n/+, S10567x2n+/))
    {
        S sx = S(1);
        S sy = S(2);
        assert(!(sx < sy) && !(sx > sy));
        assert(sx.opCmp(sy) == 0);

        assert(typeid(S).compare(&sx, &sy) == 0);
        static if (is(S == S10567x1n))
            assert(cast(void*)typeid(S).xopCmp == cast(void*)&S.opCmp, S.stringof);
    }

    foreach (S; Seq!(S10567y1n, S10567y1t/+, S10567y2n, S10567y2t+/))
    {
        S sx = S(1);
        S sy = S(2);
        assert(!(sx < sy) && !(sx > sy));
        assert(sx.opCmp(sy) == 0);

        assert(typeid(S).compare(&sx, &sy) == 0);
    }

    foreach (S; Seq!(S10567z1n, S10567z1t/+, S10567z2n, S10567z2t+/))
    {
        S sx = S(1);
        S sy = S(2);
        assert(!(sx < sy) && !(sx > sy));
        assert(sx.opCmp(sy) == 0);

        try
        {
            auto x = typeid(S).compare(&sx, &sy);
            assert(0);
        }
        catch (Error e) { assert(e.msg[$-15 .. $] == "not implemented"); }
    }
/+
    foreach (S; Seq!(S10567d1, S10567d2))
    {
        int[S] aa;
        aa[S(1)] = 10;  aa[S(1)] = 1;
        aa[S(2)] = 20;  aa[S(2)] = 2;
        assert(aa.length == 2);
        foreach (k, v; aa)
            assert(k.value == v);

        S sx = S(1);
        S sy = S(2);

        // Don't invoke opDispatch!"opCmp"
        assert(typeid(S).compare(&sx, &sy) != 0);
    }
+/
}

/**************************************/
// 11062

struct S11062ia
{
    struct S1
    {
        void opIndexAssign(int val, int key) {}
    }
    struct S2
    {
        S1 headers;
    }

    private S2 m_obj;
    @property S2 get() { return m_obj; }
    alias get this;
}

struct S11062sa
{
    struct S1
    {
        void opSliceAssign(int val, int lwr, int upr) {}
    }
    struct S2
    {
        S1 headers;
    }

    private S2 m_obj;
    @property S2 get() { return m_obj; }
    alias get this;
}

void test11062()
{
    auto sia = S11062ia();
    sia.headers[1] = 1;     // bug

    auto ssa = S11062sa();
    ssa.headers[1..2] = 1;  // bug
}

/**************************************/
// 11311

void test11311()
{
    static int ctor, cpctor, dtor;

    static struct S
    {
        this(int)  { ++ctor; }
        this(this) { ++cpctor; }
        ~this()    { ++dtor; }
    }
    static struct Arr
    {
        S data;
        ref S opIndex(int) return { return data; }
        ref S opSlice(int, int) return { return data; }
    }

    {
        Arr a = Arr(S(1));
        assert(ctor == 1);
        assert(cpctor == 0);
        assert(dtor == 0);

        auto getA1() { return a; }
      //getA1().opIndex(1);  // OK
        getA1()[1];          // NG

        assert(ctor == 1);
        assert(cpctor == 1);  // getA() returns a copy of a
        assert(dtor == 1);    // temporary returned by getA() should be destroyed
    }
    assert(dtor == 2);
    assert(ctor + cpctor == dtor);

    ctor = cpctor = dtor = 0;

    {
        Arr a = Arr(S(1));
        assert(ctor == 1);
        assert(cpctor == 0);
        assert(dtor == 0);

        auto getA2() { return a; }
      //getA2().opSlice(1, 2);  // OK
        getA2()[1..2];          // NG

        assert(ctor == 1);
        assert(cpctor == 1);  // getA() returns a copy of a
        assert(dtor == 1);    // temporary returned by getA() should be destroyed
    }
    assert(dtor == 2);
    assert(ctor + cpctor == dtor);
}

/**************************************/
// 12193

void test12193()
{
    struct Foo
    {
        bool bar;
        alias bar this;
        void opOpAssign(string op)(size_t x)
        {
            bar = false;
        }
    }

    Foo foo;
    foo <<= 1;
}

/**************************************/
// 14057

struct W14057
{
    int[] subType;
    alias subType this;

    W14057 opSlice(size_t, size_t)
    {
        return this;
    }
}

void test14057()
{
    auto w = W14057();
    W14057 w2 = w[0 .. 1337];
}

/**************************************/

struct Tuple20(T...) { T field; alias field this; }

void test20a()
{
    // ae1save in in AssignExp::semantic
    int a, b;

    struct A1
    {
        void opIndexAssign(int v, Tuple20!(int, int) ) { a = v; }
        Tuple20!(int, int) opSlice(size_t dim)(int, int) { return typeof(return).init; }
    }
    struct A2
    {
        A1 a1;
        alias a1 this;
        int opIndexAssign(int) { return b; }
    }

    stompStack();
    A2 foo() { return A2(); }
    foo()[1..2] = 1;
    // ref A1 __tmp = foo().a1; __tmp.opIndexAssign(1, __tmp.opSlice!0(1, 2));
    assert(a == 1);     // should work
    assert(b == 0);
}

void test20b()
{
    // ae1save in UnaExp::op_overload()
    int a, b;

    struct A1
    {
        void opIndexUnary(string op)(Tuple20!(int, int) ) { a = 1; }
        Tuple20!(int, int) opSlice(size_t dim)(int, int) { return typeof(return).init; }
        void dummy() {} // nessary to make A1 nested struct
    }
    struct A2
    {
        A1 a1;
        alias a1 this;
        int opIndexUnary(string op)(int) { return 0; }
    }

    stompStack();
    A2 foo() { return A2(); }
    +foo()[1..2];
    // ref A1 __tmp = foo().a1; __tmp.opIndexUnary!"+"(__tmp.opSlice!0(1, 2));
    assert(a == 1);     // should pass
    assert(b == 0);
}

void test20c()
{
    // ae1save in ArrayExp::op_overload()
    int a, b;

    struct A1
    {
        void opIndex(Tuple20!(int, int) ) { a = 1; }
        Tuple20!(int, int) opSlice(size_t dim)(int, int) { return typeof(return).init; }
    }
    struct A2
    {
        A1 a1;
        alias a1 this;
        int opIndex(int) { return 0; }
    }

    stompStack();
    A2 foo() { return A2(); }
    foo()[1..2];
    // ref A1 __tmp = foo().a1; __tmp.opIndex(__tmp.opSlice!0(1, 2));
    assert(a == 1);     // should pass
    assert(b == 0);
}

void test20d()
{
    // ae1save in BinAssignExp::op_overload()
    int a, b;

    struct A1
    {
        void opIndexOpAssign(string op)(int v, Tuple20!(int, int) ) { a = v; }
        Tuple20!(int, int) opSlice(size_t dim)(int, int) { return typeof(return).init; }
        void dummy() {} // nessary to make A1 nested struct
    }
    struct A2
    {
        A1 a1;
        alias a1 this;
        ref int opIndexOpAssign(alias op)(int) { return b; }
    }

    stompStack();
    A2 foo() { return A2(); }
    foo()[1..2] += 1;
    // ref A1 __tmp = foo().a1; __tmp.opIndexOpAssign!"+"(1, __tmp.opSlice!0(1, 2));
    assert(a == 1);     // should pass
    assert(b == 0);
}

/**************************************/
// 14624

void test14624()
{
    struct A1
    {
        int x;
        ref int opIndex() return { return x; }
        ref int opSlice() { assert(0); }
    }
    {
        A1 a = A1(1);
        auto x = a[];       // a.opIndex()
        assert(x == a.x);
        auto y = -a[];      // -a.opIndex()        <-- not found: a.opIndexUnary!"-"
        assert(y == -a.x);
        a[] = 1;            // a.opIndex() = 1;    <-- not found: a.opIndexAssign(int)
        assert(a.x == 1);
        a[] += 1;           // a.opIndex() += 1;   <-- not found: a.opIndexOpAssign!"+"(int)
        assert(a.x == 2);
    }

    struct A2
    {
        int x;
        ref int opIndex() return               { x = 10; return x; }
        ref int opSlice() { assert(0); }
        ref int opSliceUnary(alias op)()       { x = 11; return x; }
        ref int opSliceAssign(int) return      { x = 12; return x; }
        ref int opSliceOpAssign(alias op)(int) { x = 13; return x; }
    }
    {
        A2 a = A2(1);
        auto x = a[];       // a.opIndex()
        assert(a.x == 10);
        auto y = -a[];      // a.opSliceUnary!"-"()     is preferred than: -a.opIndex()
        assert(a.x == 11);
        a[] = 1;            // a.opSliceAssign(1)       is preferred than: a.opIndex() = 1;
        assert(a.x == 12);
        a[] += 1;           // a.opSliceOpAssign!"+"(1) is preferred than: a.opIndex() += 1;
        assert(a.x == 13);
    }
}

/**************************************/
// 14625

void test14625()
{
    struct R
    {
        @property bool empty() { return true; }
        @property int front() { return 0; }
        void popFront() {}
    }

    struct C1
    {
        R opIndex() { return R(); }
        R opSlice() { assert(0); }
    }
    C1 c1;
    foreach (e; c1) {}      // OK <- asserts in opSlice()
    foreach (e; c1[]) {}    // OK, opIndex()

    struct C2
    {
        R opIndex() { return R(); }
    }
    C2 c2;
    foreach (e; c2) {}      // OK <- rejected
    foreach (e; c2[]) {}    // OK, opIndex()
}

/**************************************/

int main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test9();
    test10();
    test11();
    test4099();
    test12();
    test13();
    test14();
    test15();
    test16();
    test17();
    test3789();
    test10037();
    test6798();
    test12904();
    test7641();
    test8434();
    test18();
    test19();
    test9453();
    test9496();
    test9689();
    test9694();
    test10064();
    test12585();
    test10394();
    test10567();
    test11062();
    test11311();
    test14057();
    test20a();
    test20b();
    test20c();
    test20d();
    test14624();
    test14625();

    printf("Success\n");
    return 0;
}