[clang-tidy] add missing assignment operations in hicpp-signed-bitwise

[JonasToth]

Summary

This patch resolves the bug https://bugs.llvm.org/show_bug.cgi?id=36963.

• implement missing assignment operators for hicpp-signed-bitwise
• add tests
• mention fix in release notes

[JonasToth]

• fix std bitmask type shifting issue

[aaron.ballman]

LG aside from a diagnostic wording nit.

clang-tidy/hicpp/SignedBitwiseCheck.cpp

92

How about: "shifting a value of bitmask type"

[JonasToth]

clang-tidy/hicpp/SignedBitwiseCheck.cpp

92

Not sure about that.

The general bitmasks are covered by the second diag.

This one should only trigger if a shift with the standardized bitmask types occurs. This exception is necessary because those are allowed for the other bitwise operations(&, |, ^), but i decided that shifting them makes no sense.

[aaron.ballman]

clang-tidy/hicpp/SignedBitwiseCheck.cpp

92

I think "standardized bitmask type" is not very clear because it's hard to know what is and isn't a standardized bitmask type (it's not a term of art I'm used to hearing, anyway). I agree that shifting by them makes no sense, but I also have a hard time imagining anyone is using these as shift values in the first place, so perhaps the diagnostic can be removed entirely unless we can find some code in the wild that does something like this?

[JonasToth]

clang-tidy/hicpp/SignedBitwiseCheck.cpp

92

I totally agree that its bad.

Removing this exception is ok with me.

[aaron.ballman]

clang-tidy/hicpp/SignedBitwiseCheck.cpp

92

Okay, we'll go that route -- we can always bring it back if it turns out to have value later. Thanks!

[JonasToth]

• remove shifting exception for standarized bitmask types

[JonasToth]

Commit in https://reviews.llvm.org/rCTE329789

clang-tidy/hicpp/SignedBitwiseCheck.cpp

const auto BitmaskType = namedDecl(anyOf(
       hasName("::std::ios_base::fmtflags"), hasName("::std::ios_base::iostate"),
       hasName("::std::ios_base::openmode")));
   const auto IsStdBitmask = ignoringImpCasts(declRefExpr(hasType(BitmaskType)));
 
   // Match binary bitwise operations on signed integer arguments.
   Finder->addMatcher(
       binaryOperator(
           allOf(anyOf(hasOperatorName("^"), hasOperatorName("|"),
-                      hasOperatorName("&")),
+                      hasOperatorName("&"), hasOperatorName("^="),
+                      hasOperatorName("|="), hasOperatorName("&=")),
 
                 unless(allOf(hasLHS(IsStdBitmask), hasRHS(IsStdBitmask))),
 
                 hasEitherOperand(SignedIntegerOperand),
                 hasLHS(hasType(isInteger())), hasRHS(hasType(isInteger()))))
           .bind("binary-no-sign-interference"),
       this);
 
   // Shifting and complement is not allowed for any signed integer type because
   // the sign bit may corrupt the result.
   Finder->addMatcher(
-      binaryOperator(allOf(anyOf(hasOperatorName("<<"), hasOperatorName(">>")),
-                           hasEitherOperand(SignedIntegerOperand),
-                           hasLHS(hasType(isInteger())),
-                           hasRHS(hasType(isInteger()))))
+      binaryOperator(
+          allOf(anyOf(hasOperatorName("<<"), hasOperatorName(">>"),
+                      hasOperatorName("<<="), hasOperatorName(">>=")),
+                hasLHS(hasType(isInteger())), hasRHS(hasType(isInteger()))))
           .bind("binary-sign-interference"),
       this);
 
   // Match unary operations on signed integer types.
   Finder->addMatcher(unaryOperator(allOf(hasOperatorName("~"),
                                          hasUnaryOperand(SignedIntegerOperand)))
                          .bind("unary-signed"),
                      this);
if (const auto *BinaryOp =
             N.getNodeAs<BinaryOperator>("binary-no-sign-interference"))
       Location = BinaryOp->getLocStart();
     else if (const auto *BinaryOp =
                  N.getNodeAs<BinaryOperator>("binary-sign-interference"))
       Location = BinaryOp->getLocStart();
     else
       llvm_unreachable("unexpected matcher result");
   }
-
-  diag(Location,
-       "use of a signed integer operand with a %select{binary|unary}0 bitwise "
-       "operator")
+  diag(Location, "use of a signed integer operand with a "
+                 "%select{binary|unary}0 bitwise operator")
       << IsUnary << SignedOperand->getSourceRange();
 }
 
 } // namespace hicpp
 } // namespace tidy
 } // namespace clang

docs/ReleaseNotes.rst

- New :doc:`zircon-temporary-objects
 
   Warns on construction of specific temporary objects in the Zircon kernel.
 
 - New alias :doc:`hicpp-avoid-goto
   <clang-tidy/checks/hicpp-avoid-goto>` to :doc:`cppcoreguidelines-avoid-goto
   <clang-tidy/checks/cppcoreguidelines-avoid-goto>`
   added.
 
+- Adding the missing bitwise assignment operations to 
+  :doc:`hicpp-signed-bitwise <clang-tidy/checks/hicpp-signed-bitwise>`.
+
 - The 'misc-forwarding-reference-overload' check was renamed to :doc:`bugprone-forwarding-reference-overload
   <clang-tidy/checks/bugprone-forwarding-reference-overload>`
 
 - The 'misc-incorrect-roundings' check was renamed to :doc:`bugprone-incorrect-roundings
   <clang-tidy/checks/bugprone-incorrect-roundings>`
 
 - The 'misc-lambda-function-name' check was renamed to :doc:`bugprone-lambda-function-name
   <clang-tidy/checks/bugprone-lambda-function-name>`

test/clang-tidy/hicpp-signed-bitwise-standard-types.cpp

 // RUN: clang-tidy %s -checks='-*,hicpp-signed-bitwise' -- -std=c++11
 
 #include "hicpp-signed-bitwise-standard-types.h"
 
 void pure_bitmask_types() {
   // std::locale::category
   int SResult = 0;
   std::locale::category C = std::locale::category::ctype;
 
   SResult = std::locale::category::none | std::locale::category::collate;
+  SResult|= std::locale::category::collate;
   SResult = std::locale::category::ctype & std::locale::category::monetary;
+  SResult&= std::locale::category::monetary;
   SResult = std::locale::category::numeric ^ std::locale::category::time;
+  SResult^= std::locale::category::time;
   SResult = std::locale::category::messages | std::locale::category::all;
 
   SResult = std::locale::category::all & C;
+  SResult&= std::locale::category::all;
   SResult = std::locale::category::all | C;
+  SResult|= std::locale::category::all;
   SResult = std::locale::category::all ^ C;
+  SResult^= std::locale::category::all;
 
   // std::ctype_base::mask
   std::ctype_base::mask M = std::ctype_base::mask::punct;
 
   SResult = std::ctype_base::mask::space | std::ctype_base::mask::print;
   SResult = std::ctype_base::mask::cntrl & std::ctype_base::mask::upper;
   SResult = std::ctype_base::mask::lower ^ std::ctype_base::mask::alpha;
-  SResult = std::ctype_base::mask::digit | std::ctype_base::mask::punct;
-  SResult = std::ctype_base::mask::xdigit & std::ctype_base::mask::alnum;
-  SResult = std::ctype_base::mask::alnum ^ std::ctype_base::mask::graph;
-
-  SResult = std::ctype_base::mask::space & M;
-  SResult = std::ctype_base::mask::space | M;
-  SResult = std::ctype_base::mask::space ^ M;
+  SResult|= std::ctype_base::mask::digit | std::ctype_base::mask::punct;
+  SResult&= std::ctype_base::mask::xdigit & std::ctype_base::mask::alnum;
+  SResult^= std::ctype_base::mask::alnum ^ std::ctype_base::mask::graph;
+
+  SResult&= std::ctype_base::mask::space & M;
+  SResult|= std::ctype_base::mask::space | M;
+  SResult^= std::ctype_base::mask::space ^ M;
 
   // std::ios_base::fmtflags
   std::ios_base::fmtflags F = std::ios_base::fmtflags::floatfield;
 
   SResult = std::ios_base::fmtflags::dec | std::ios_base::fmtflags::oct;
   SResult = std::ios_base::fmtflags::hex & std::ios_base::fmtflags::basefield;
   SResult = std::ios_base::fmtflags::left ^ std::ios_base::fmtflags::right;
-  SResult = std::ios_base::fmtflags::internal | std::ios_base::fmtflags::adjustfield;
-  SResult = std::ios_base::fmtflags::scientific & std::ios_base::fmtflags::fixed;
-  SResult = std::ios_base::fmtflags::floatfield ^ std::ios_base::fmtflags::boolalpha;
+  SResult|= std::ios_base::fmtflags::internal | std::ios_base::fmtflags::adjustfield;
+  SResult&= std::ios_base::fmtflags::scientific & std::ios_base::fmtflags::fixed;
+  SResult^= std::ios_base::fmtflags::floatfield ^ std::ios_base::fmtflags::boolalpha;
   SResult = std::ios_base::fmtflags::showbase | std::ios_base::fmtflags::showpoint;
   SResult = std::ios_base::fmtflags::showpos & std::ios_base::fmtflags::skipws;
   SResult = std::ios_base::fmtflags::unitbuf ^ std::ios_base::fmtflags::uppercase;
 
-  SResult = std::ios_base::fmtflags::unitbuf | F;
-  SResult = std::ios_base::fmtflags::unitbuf & F;
-  SResult = std::ios_base::fmtflags::unitbuf ^ F;
+  SResult|= std::ios_base::fmtflags::unitbuf | F;
+  SResult&= std::ios_base::fmtflags::unitbuf & F;
+  SResult^= std::ios_base::fmtflags::unitbuf ^ F;
 
   // std::ios_base::iostate
   std::ios_base::iostate S = std::ios_base::iostate::goodbit;
 
-  SResult = std::ios_base::iostate::goodbit | std::ios_base::iostate::badbit;
-  SResult = std::ios_base::iostate::failbit & std::ios_base::iostate::eofbit;
-  SResult = std::ios_base::iostate::failbit ^ std::ios_base::iostate::eofbit;
+  SResult^= std::ios_base::iostate::goodbit | std::ios_base::iostate::badbit;
+  SResult|= std::ios_base::iostate::failbit & std::ios_base::iostate::eofbit;
+  SResult&= std::ios_base::iostate::failbit ^ std::ios_base::iostate::eofbit;
 
   SResult = std::ios_base::iostate::goodbit | S;
   SResult = std::ios_base::iostate::goodbit & S;
   SResult = std::ios_base::iostate::goodbit ^ S;
 
   // std::ios_base::openmode
   std::ios_base::openmode B = std::ios_base::openmode::binary;
 
   SResult = std::ios_base::openmode::app | std::ios_base::openmode::binary;
   SResult = std::ios_base::openmode::in & std::ios_base::openmode::out;
   SResult = std::ios_base::openmode::trunc ^ std::ios_base::openmode::ate;
 
-  SResult = std::ios_base::openmode::trunc | B;
-  SResult = std::ios_base::openmode::trunc & B;
-  SResult = std::ios_base::openmode::trunc ^ B;
+  SResult&= std::ios_base::openmode::trunc | B;
+  SResult^= std::ios_base::openmode::trunc & B;
+  SResult|= std::ios_base::openmode::trunc ^ B;
 }
 
 void still_forbidden() {
   // std::locale::category
   unsigned int UResult = 0u;
   int SResult = 0;
 
   SResult = std::ctype_base::mask::print ^ 8u;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   SResult = std::ctype_base::mask::cntrl | 8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   SResult = std::ctype_base::mask::upper & 8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   SResult = std::ctype_base::mask::lower ^ -8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   
+  // Staying within the allowed standard types is ok for bitwise assignment
+  // operations.
+  std::ctype_base::mask var = std::ctype_base::mask::print;
+  var<<= std::ctype_base::mask::upper;
+  var>>= std::ctype_base::mask::upper;
+  var &= std::ctype_base::mask::upper;
+  var |= std::ctype_base::mask::upper;
+  var ^= std::ctype_base::mask::upper;
+
   UResult = std::locale::category::collate << 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::locale::category::ctype << 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::locale::category::monetary >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::locale::category::numeric >> 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = ~std::locale::category::messages;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
   SResult = ~std::locale::category::all;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
 
   // std::ctype_base::mask
   UResult = std::ctype_base::mask::space | 8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ctype_base::mask::print & 8u;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ctype_base::mask::cntrl ^ -8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = std::ctype_base::mask::upper << 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ctype_base::mask::lower << 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ctype_base::mask::alpha >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ctype_base::mask::digit >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = ~std::ctype_base::mask::punct;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
   SResult = ~std::ctype_base::mask::xdigit;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
 
   // std::ios_base::fmtflags
   UResult = std::ios_base::fmtflags::dec | 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::fmtflags::oct & 1u;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::fmtflags::hex ^ -1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = std::ios_base::fmtflags::basefield >> 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::fmtflags::left >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::fmtflags::right << 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::fmtflags::internal << 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = ~std::ios_base::fmtflags::adjustfield;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
   SResult = ~std::ios_base::fmtflags::scientific;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
 
   // std::ios_base::iostate
   UResult = std::ios_base::iostate::goodbit | 8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::iostate::badbit & 8u;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::iostate::failbit ^ -8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = std::ios_base::iostate::eofbit << 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::iostate::goodbit << 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::iostate::badbit >> 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::iostate::failbit >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = ~std::ios_base::iostate::eofbit;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
   SResult = ~std::ios_base::iostate::goodbit;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
 
   // std::ios_base::openmode
   UResult = std::ios_base::app | 8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::binary & 8u;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::in ^ -8;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = std::ios_base::out >> 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::trunc >> 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::ate << 1;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = std::ios_base::ate << 1u;
-  // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = ~std::ios_base::openmode::app;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
   SResult = ~std::ios_base::openmode::binary;
   // CHECK-MESSAGES: [[@LINE-1]]:13: warning: use of a signed integer operand with a unary bitwise operator
 }

test/clang-tidy/hicpp-signed-bitwise.cpp

void binary_bitwise() {
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   SResult = SValue & SValue;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = SValue & 1;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   UResult = SValue & -1;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
+  UResult&= 1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
 
   UResult = UValue & 1u;     // Ok
   UResult = UValue & UValue; // Ok
+  UResult&= 2u;              // Ok
 
   unsigned char UByte1 = 0u;
   unsigned char UByte2 = 16u;
   signed char SByte1 = 0;
   signed char SByte2 = 16;
 
   UByte1 = UByte1 & UByte2; // Ok
   UByte1 = SByte1 & UByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
   UByte1 = SByte1 & SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
   SByte1 = SByte1 & SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
 
   // More complex expressions.
   UResult = UValue & (SByte1 + (SByte1 | SByte2));
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use of a signed integer operand with a binary bitwise operator
   // CHECK-MESSAGES: :[[@LINE-2]]:33: warning: use of a signed integer operand with a binary bitwise operator
 
   // The rest is to demonstrate functionality but all operators are matched equally.
   // Therefore functionality is the same for all binary operations.
   UByte1 = UByte1 | UByte2; // Ok
   UByte1 = UByte1 | SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1|= SByte2;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1|= UByte2; // Ok
 
   UByte1 = UByte1 ^ UByte2; // Ok
   UByte1 = UByte1 ^ SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1^= SByte2;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1^= UByte2; // Ok
 
   UByte1 = UByte1 >> UByte2; // Ok
   UByte1 = UByte1 >> SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1>>= SByte2;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1>>= UByte2; // Ok
 
   UByte1 = UByte1 << UByte2; // Ok
   UByte1 = UByte1 << SByte2;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1<<= SByte2;
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
+  UByte1<<= UByte2; // Ok
 
   int SignedInt1 = 1 << 12;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use of a signed integer operand with a binary bitwise operator
   int SignedInt2 = 1u << 12;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: use of a signed integer operand with a binary bitwise operator
 }
 
 void f1(unsigned char c) {}
void classicEnums() {
   e3 = e1 | e2;             // Ok
   e3 = e1 & e2;             // Ok
   e3 = e1 ^ e2;             // Ok
 
   OldSigned s1 = IntOne, s2 = IntTwo;
   int s3;
   s3 = IntOne | IntTwo; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
+  s3|= IntTwo; // Signed
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
   s3 = IntOne & IntTwo; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
+  s3&= IntTwo; // Signed
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
   s3 = IntOne ^ IntTwo; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
+  s3^= IntTwo; // Signed
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: use of a signed integer operand with a binary bitwise operator
   s3 = s1 | s2; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
   s3 = s1 & s2; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
   s3 = s1 ^ s2; // Signed
   // CHECK-MESSAGES: [[@LINE-1]]:8: warning: use of a signed integer operand with a binary bitwise operator
 }