MoveChecker causes false positives with no way to fix

[mattiasj-axis]

As a dumb example

#include <utility>
struct Foo {
    Foo() {}
    Foo(Foo&&o) { o._is_valid = false; }
    bool is_valid() { return _is_valid; }
private:
    bool _is_valid = true;
};

int main() {
    Foo a;
    Foo b{std::move(a)};

    if (a.is_valid()) { return 0; } else { return 1; }
}

Where is_valid is actually a check if this object is usable, the MoveChecker is hardcoded to assume that this function must be called [is]empty. This should presumably be an attribute, such as clang::movesafe so that functions that are coded movesafe can be tagged properly.

Likewise, clang::movestatereset or something like such should be introduced for functions that reset the state (but I haven't had that issue, yet).

[llvmbot]

@llvm/issue-subscribers-clang-static-analyzer

[haoNoQ]

While I agree that such attributes could be helpful, I'm really curious how does the original use case rule out the possibility to simply create a new local variable instead of reusing the storage. In the vastly typical scenario there's simply no incentive to deal with the complexity of storage reuse when local variables are basically free and the moved-from object is typically empty enough to not provide any reuse value.

Note that for the non-local variables this check simply doesn't fire; it only fires on non-locals when the class is standard and the semantics of every method are known and the moved-from state is explicitly known to be hazardous, eg. dereference of moved smart pointer (known to be null) or pattern-matching a moved-from string (known to be in unspecified state).