Struct d'tors and destructive assignment of return vals

[dsimcha]

import std.stdio;

struct RC {
    uint N;

    this(this) {
        writeln("Postblit:  ", N);
    }

    ~this() {
        writeln("D'tor:  ", N);
    }
}

RC fun() {
    writeln("Doing stuff...");
    return RC(3);
}


void main() {
    RC foo = RC(1);
    writeln("Calling fun()...");
    foo = fun();
    writeln("Exiting...");
}

Output:

Calling fun()...
Doing stuff...
D'tor:  1
Exiting...
D'tor:  3

Would it be feasible to require that, when a struct is being destructively
assigned the return value of a function, the d'tor is called for the old
contents before the function that provides the return value is called instead
of calling it after?  This would be useful, for example, for providing COW
semantics when dealing with ranges whose elements are lazily constructed arrays:

struct SomeRange {
    T[] someArray;
    uint* nExternalReferences;  // to someArray.

    T[] popNext() {
        if(*nExternalReferences > 0) {
            someArray = someArray.dup;
            nExternalReferences = new uint;
        }

        // Modify someArray.
        return referenceCounted(someArray, nExternalReferences);
    }
}

Caller's end:

SomeRange s;
RefCounted r;
while(!s.empty) {
    // The underlying array will constantly be dup'd because
    // the d'tor for r is not being called until after popNext()
    // is called.
    r = s.popNext;
}