// REQUIRED_ARGS: -unittest
// https://issues.dlang.org/show_bug.cgi?id=4375
// disallow dangling else

void main() {

	if (true) {
		if (false) {
			assert(1);
		} else {
			assert(2);
		}
	}


    if (true) {
        if (false)
            assert(7);
    } else
        assert(8);


    if (true) {
        if (false)
            assert(9);
        else
            assert(10);
    }


    {
        if (true)
            assert(11);
        else
            assert(12);
    }


    {
label1:
        if (true)
            assert(13);
        else
            assert(14);
    }


	if (true)
		foreach (i; 0 .. 5) {
			if (true)
				assert(17);
            else
                assert(18);
        }


	if (true) {
		foreach (i; 0 .. 5)
			if (true)
				assert(18.1);
    } else
        assert(18.2);


    if (true)
        assert(19);
    else
        assert(20);


    if (true)
        assert(21);
    else if (false)
        assert(22);
    else
        assert(23);


    version (A) {
        if (true)
            assert(26);
    } else
        assert(27);


    version (A) {
        if (true)
            assert(28);
        else
            assert(29);
    }


    version (A)
        assert(30);
    else version (B)
        assert(31);
    else
        assert(32);


    static if (true) {
        static if (true)
            assert(35);
    } else
        assert(36);


    static if (true) {
        static if (true)
            assert(37);
        else
            assert(38);
    }


    static if (true)
        assert(39);
    else static if (true)
        assert(40);
    else
        assert(41);

    switch (4) {
        case 0:
            if (true)
                assert(42);
            else
                assert(43);
            break;
        case 1: .. case 5:
            if (true)
                assert(44);
            else
                assert(45);
            break;
        default:
            if (true)
                assert(46);
            else
                assert(47);
            break;
    }

    // (o_O)
    switch (1)
        default:
            if (true)
                assert(113);
            else
                assert(114);

    // (o_O)
    final switch (1)
        case 1:
            if (true)
                assert(117);
            else
                assert(118);

    mixin(q{
        if (true)
            assert(56);
        else
            assert(57);
    });



    while (false)
        if (true)
            assert(66);
        else
            assert(67);


    if (true)
        while (false)
            assert(68);
    else
        assert(69);


    do
        if (true)
            assert(72);
        else
            assert(73);
    while (false);


    if (true)
        do
            if (true)
                assert(74);
            else
                assert(75);
        while (false);

    for (
        if (true)        // (o_O)
            assert(78);
        else
            assert(79);
        false; false
    )
        if (true)
            assert(80);
        else
            assert(81);

    if (true)
        for (if (true) assert(84); else assert(85); false;)
            assert(86);


    if (true)
        if (true)
            if (true)
                if (true)
                    if (true)
                        assert(87);

    auto x = new C;


    if (true)
        while (false)
            for (;;)
                scope (exit)
                    synchronized (x)
                        assert(88);
    else
        assert(89);


    if (true)
        while (false)
            for (;;) {
                scope (exit)
                    synchronized (x)
                        if (true)
                            assert(90);
                        else
                            assert(89);
            }


    if (true)
        while (false)
            for (;;)
                scope (exit)
                    synchronized (x)
                        if (true)
                            assert(90);
                        else
                            assert(89);
    else
        assert(12);


    with (x)
        if (false)
            assert(92);
        else
            assert(93);


    try
        if (true)
            assert(94);
        else
            assert(95);
    catch (Exception e)
        if (true)
            assert(96);
        else
            assert(97);
    finally
        if (true)
            assert(98);
        else
            assert(99);


    if (true)
        try
            if (true)
                assert(100);
            else
                assert(101);
        finally
            assert(102);

    if (true)
        try
            assert(109);
        catch(Exception e)
            if (true)
                assert(110);
            else
                assert(112);
        finally
            assert(111);

    static struct F {
        static if (true)
            int x;
        else
            int y;

        static if (true) {
            static if (false)
                int z;
        } else
            int w;

        static if (true)
            int t;
        else static if (false)
            int u;
        else
            int v;
    }

    if (true)
        if (true)
            assert(113);
        else
            assert(114);
    else
        assert(115);

    static if (true)
        static if (true)
            assert(116);
        else
            assert(117);
    else
        assert(118);

}

unittest {
    if (true)
        assert(50);
    else
        assert(51);
}

class C {
    invariant() {
        if (true)
            assert(58);
        else
            assert(59);
    }

    int f()
    in {
        if (true)
            assert(60);
        else
            assert(61);
    }
    out(res) {
        if (true)
            assert(62);
        else
            assert(63);
    }
    do {
        if (true)
            assert(64);
        else
            assert(65);
        return 0;
    }
}

enum q = q{
    if(true)
        if(true)
            assert(54.1);
    else
        assert(55.2);
};

static if (true)
    struct F0 {}
else static if (true)
    struct F1 {}
else
    struct F2 {}

static if (true) {
    static if (false)
        struct F3 {}
} else
    struct F4 {}

version(A) {
    version(B)
        struct F5 {}
} else
    struct F6 {}

version(A) {
    version(B)
        struct F5a {}
    else
        struct F5b {}
}

version (C)
    struct F5c {}
else
    struct F5d {}

struct F7 {
    static if (true)
        int x;
    else
        float x;

private:
    static if (true)
        int y;
    else
        float y;
}

template F8() {
    static if (true)
        int x;
    else
        float x;
}

static if (true)
    align(1)
        static if (false)
            struct F9 {}

static if (true)
    align(1) {
        extern(C)
            pure
                static if (false)
                    void F10(){}
                else
                    void F11(){}
    }


void f() {
    int[] x;
    static if (5 > 0)
        version (Y)
            scope (failure)
                foreach (i, e; x)
                    while (i > 20)
                        with (e)
                            if (e < 0)
                                synchronized(e)
                                    assert(1);
                            else
                                assert(2);
        else
            x = null;
    else
        x = null;
}
