https://issues.dlang.org/show_bug.cgi?id=24810

          Issue ID: 24810
           Summary: stable sort does not work with structs that both
                    define opAssign and disable default-initialization
           Product: D
           Version: D2
          Hardware: All
                OS: All
            Status: NEW
          Severity: normal
          Priority: P1
         Component: phobos
          Assignee: nobody@puremagic.com
          Reporter: issues.dlang@jmdavisProg.com

The fix for https://issues.dlang.org/show_bug.cgi?id=24773 made it so that this code no longer compiles:

void main()
{
    static struct E
    {
        int value;
        int valid = 42;

        this(int value)
        {
            this.value = value;
        }

        @disable this();

        ~this()
        {
            //assert(valid == 42);
        }
    }

    import std.array : array;
    import std.range : chain, only, repeat;
    auto arr = chain(repeat(E(41), 18),
                     only(E(39)),
                     repeat(E(41), 16),
                     only(E(1)),
                     repeat(E(42), 33),
                     only(E(33)),
                     repeat(E(42), 16),
                     repeat(E(43), 27),
                     only(E(33)),
                     repeat(E(43), 34),
                     only(E(34)),
                     only(E(43)),
                     only(E(63)),
                     repeat(E(44), 42),
                     only(E(27)),
                     repeat(E(44), 11),
                     repeat(E(45), 64),
                     repeat(E(46), 3),
                     only(E(11)),
                     repeat(E(46), 7),
                     only(E(4)),
                     repeat(E(46), 34),
                     only(E(36)),
                     repeat(E(46), 17),
                     repeat(E(47), 36),
                     only(E(39)),
                     repeat(E(47), 26),
                     repeat(E(48), 17),
                     only(E(21)),
                     repeat(E(48), 5),
                     only(E(39)),
                     repeat(E(48), 14),
                     only(E(58)),
                     repeat(E(48), 24),
                     repeat(E(49), 13),
                     only(E(40)),
                     repeat(E(49), 38),
                     only(E(18)),
                     repeat(E(49), 11),
                     repeat(E(50), 6)).array();

    import std.algorithm.mutation : SwapStrategy;
    import std.algorithm.sorting : sort;
    arr.sort!((a, b) => a.value < b.value, SwapStrategy.stable)();
}

However, prior to that fix, if you uncommented the comment in the destructor, the assertion failed, because (as the fix was intended to fix), stable sort was assigning to uninitialized memory even when the type defined opAssign. So, while the change caused code to no longer compile, the code that stopped compiling was actually broken.

The fix that caused this code to be a compilation error instead of being buggy code that compiled took the easy route of just using initialized memory, which is fine in the vast majority of cases. However, larger changes will be necessary to deal with types that don't allow default initialization.

The example given here is an altered version of the one from https://issues.dlang.org/show_bug.cgi?id=24809 (which shows a case which the fix for https://issues.dlang.org/show_bug.cgi?id=24773 did not catch and which also needs to be fixed).

--