[clang-tidy] Check request: modernize-use-std-exchange

[denzor200]

Needs a check that will find places in the code with potential for using std::exchange and will suggest using it.

At least this feature should be implemented for checking move-constructors and move-assignments.

BEFORE:

struct S
{
    int n;
 
    S(S&& other) noexcept {
        n = other.n;
        other.n = 0;
    }

    S& operator=(S&& other) noexcept {
        if (this != &other) {
            n = other.n;
            other.n = 0;
        }
        return *this;
    }
};

AFTER:

struct S
{
    int n;
 
    S(S&& other) noexcept {
        n = std::exchange(other.n, 0);
    }

    S& operator=(S&& other) noexcept {
        n = std::exchange(other.n, 0);
        return *this;
    }
};

Also I suppose it's possible to implement checking of regular functions.

BEFORE:

class stream
{
public:
    int flags(int newf) {
        const int old_flags = flags_;
        flags_ = newf;
        return old_flags;
    }
private:
    int flags_ = 0;
};

AFTER:

class stream
{
public:
    int flags(int newf) { return std::exchange(flags_, newf); }
private:
    int flags_ = 0;
};

[llvmbot]

@llvm/issue-subscribers-clang-tidy

Author: Denis Mikhailov (denzor200)

Needs a check that will find places in the code with potential for using std::exchange and will suggest using it.

At least this feature should be implemented for checking move-constructors and move-assignments.

BEFORE:

struct S
{
    int n;
 
    S(S&& other) noexcept {
        n = other.n;
        other.n = 0;
    }

    S& operator=(S&& other) noexcept {
        if (this != &other) {
            n = other.n;
            other.n = 0;
        }
        return *this;
    }
};

AFTER:

struct S
{
    int n;
 
    S(S&& other) noexcept {
        n = std::exchange(other.n, 0);
    }

    S& operator=(S&& other) noexcept {
        n = std::exchange(other.n, 0);
        return *this;
    }
};

Also I suppose it's possible to implement checking of regular functions.

BEFORE:

class stream
{
public:
    int flags(int newf) {
        const int old_flags = flags_;
        flags_ = newf;
        return old_flags;
    }
private:
    int flags_ = 0;
};

AFTER:

class stream
{
public:
    int flags(int newf) { return std::exchange(flags_, newf); }
private:
    int flags_ = 0;
};

[denzor200]

std::exchange is also a well-known way to implement printing of contained elements separated by a delimiter.

BEFORE:

for (int i=0;i<vec.size();++i) {
    std::cout << (i==0 ? "" : ", ") << vec[i];
}

AFTER:

const char* div = "";
for (int val : vec) {
    std::cout << std::exchange(div, ", ") << val;
}

Is is possible to implement the check to change that printing loop? Will Clang Tidy's capacity be enough?

[localspook]

#68870 also mentions a slightly harder case, where the first assignment is in an initializer list:

 Foo(Foo&& other) noexcept
-  : m_{other.m_}
+  : m_{std::exchange(other.m_, nullptr)}
 {
-  other.m_ = nullptr;
 }

Also, the check should ignore cases where either of the variables is a bitfield, because std::exchange takes references, which can't bind to bitfields.

[denzor200]

Yet another case to match:

class stream
{
public:
    int flags(int newf) {
-      prev_flags_ = flags_;
-      flags_ = newf;
+      prev_flags_ = std::exchange(flags_, newf);
    }
private:
    int prev_flags_ = 0;
    int flags_ = 0;
};