Expr *LHS, Expr *RHS) {
switch (Opc) {
case BO_Assign:
+ // In the non-overloaded case, we warn about self-assignment (x = x) for
+ // both simple assignment and certain compound assignments where algebra
+ // tells us the operation yields a constant result. When the operator is
+ // overloaded, we can't do the latter because we don't want to assume that
+ // those algebraic identities still apply; for example, a path-building
+ // library might use operator/= to append paths. But it's still reasonable
+ // to assume that simple assignment is just moving/copying values around
+ // and so self-assignment is likely a bug.
+ DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
+ [[fallthrough]];
case BO_DivAssign:
case BO_RemAssign:
case BO_SubAssign:
case BO_AndAssign:
case BO_OrAssign:
case BO_XorAssign:
- DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
CheckIdentityFieldAssignment(LHS, RHS, OpLoc, S);
break;
default:
#ifndef DUMMY
a *= a;
- a /= a; // expected-warning {{explicitly assigning}}
- a %= a; // expected-warning {{explicitly assigning}}
+ a /= a;
+ a %= a;
a += a;
- a -= a; // expected-warning {{explicitly assigning}}
+ a -= a;
a <<= a;
a >>= a;
- a &= a; // expected-warning {{explicitly assigning}}
- a |= a; // expected-warning {{explicitly assigning}}
- a ^= a; // expected-warning {{explicitly assigning}}
+ a &= a;
+ a |= a;
+ a ^= a;
#endif
}