[clang] Merged diagnostic warn_condition_is_assignment into generic warn_assignment_bool_context

PhilippRados · PhilippRados · commit b72f7a736ea3 · 2025-02-25T18:26:17.000+01:00
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -8474,9 +8474,6 @@ def err_cannot_form_pointer_to_member_of_reference_type : Error<
 def err_incomplete_object_call : Error<
   "incomplete type in call to object of type %0">;
 
-def warn_condition_is_assignment : Warning<"using the result of an "
-  "assignment as a condition without parentheses">,
-  InGroup<Parentheses>;
 def warn_assignment_bool_context : Warning<"using the result of an assignment as a truth value without parentheses">,
   InGroup<Parentheses>;
 
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
@@ -20203,7 +20203,7 @@ bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
 void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
   SourceLocation Loc;
 
-  unsigned diagnostic = diag::warn_condition_is_assignment;
+  unsigned diagnostic = diag::warn_assignment_bool_context;
   bool IsOrAssign = false;
 
   if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
diff --git a/clang/test/CodeCompletion/crash-skipped-bodies-template-inst.cpp b/clang/test/CodeCompletion/crash-skipped-bodies-template-inst.cpp
@@ -6,15 +6,15 @@ auto make_func() {
       int x;
       if (x = 10) {}
       // Check that body of this function is actually skipped.
-      // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a condition without parentheses
+      // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a truth value without parentheses
       return this;
     }
   };
 
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: crash-skipped-bodies-template-inst.cpp:15:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: crash-skipped-bodies-template-inst.cpp:15:9: warning: using the result of an assignment as a truth value without parentheses
   return impl();
 }
 
diff --git a/clang/test/CodeCompletion/skip-auto-funcs.cpp b/clang/test/CodeCompletion/skip-auto-funcs.cpp
@@ -7,7 +7,7 @@ auto not_skipped() {
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: 8:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: 8:9: warning: using the result of an assignment as a truth value without parentheses
   return 1;
 }
 
@@ -16,7 +16,7 @@ auto lambda_not_skipped = []() {
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: 17:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: 17:9: warning: using the result of an assignment as a truth value without parentheses
   return 1;
 }
 
@@ -25,15 +25,15 @@ auto skipped() -> T {
   int x;
   if (x = 10) {}
   // Check that this function is skipped.
-  // CHECK-NOT: 26:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK-NOT: 26:9: warning: using the result of an assignment as a truth value without parentheses
   return 1;
 };
 
 auto lambda_skipped = []() -> int {
   int x;
   if (x = 10) {}
   // This could potentially be skipped, but it isn't at the moment.
-  // CHECK: 34:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: 34:9: warning: using the result of an assignment as a truth value without parentheses
   return 1;
 };
 
@@ -42,7 +42,7 @@ decltype(auto)** not_skipped_ptr() {
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: 43:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: 43:9: warning: using the result of an assignment as a truth value without parentheses
   return T();
 }
 
@@ -51,7 +51,7 @@ decltype(auto) not_skipped_decltypeauto() {
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: 52:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: 52:9: warning: using the result of an assignment as a truth value without parentheses
   return 1;
 }
 
diff --git a/clang/test/Misc/warning-flags-enabled.c b/clang/test/Misc/warning-flags-enabled.c
@@ -4,7 +4,7 @@
 // We just check a few to make sure it's doing something sensible.
 //
 // CHECK: ext_unterminated_char_or_string
-// CHECK: warn_condition_is_assignment
+// CHECK: warn_assignment_bool_context
 // CHECK: warn_null_arg
 
 
diff --git a/clang/test/Modules/diag-pragma.c b/clang/test/Modules/diag-pragma.c
@@ -6,7 +6,7 @@
 @import diag_pragma;
 
 int foo(int x) {
-  if (x = DIAG_PRAGMA_MACRO) // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = DIAG_PRAGMA_MACRO) // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                              // expected-note {{place parentheses}} expected-note {{use '=='}}
     return 0;
   return 1;
diff --git a/clang/test/Modules/diag-pragma.cpp b/clang/test/Modules/diag-pragma.cpp
@@ -40,7 +40,7 @@ int foo(int x) {
 
   void("bar" + x);
 
-  if (x = DIAG_PRAGMA_MACRO) // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = DIAG_PRAGMA_MACRO) // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                              // expected-note {{place parentheses}} expected-note {{use '=='}}
     return 0;
   return 1;
diff --git a/clang/test/OpenMP/crash-skipped-bodies-template-inst.cpp b/clang/test/OpenMP/crash-skipped-bodies-template-inst.cpp
@@ -9,15 +9,15 @@ auto make_func() {
         ;
       }
       // Check that body of this function is actually skipped.
-      // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a condition without parentheses
+      // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a truth value without parentheses
       return this;
     }
   };
 
   int x;
   if (x = 10) {}
   // Check that this function is not skipped.
-  // CHECK: crash-skipped-bodies-template-inst.cpp:18:9: warning: using the result of an assignment as a condition without parentheses
+  // CHECK: crash-skipped-bodies-template-inst.cpp:18:9: warning: using the result of an assignment as a truth value without parentheses
   return impl();
 }
 
diff --git a/clang/test/Sema/parentheses.c b/clang/test/Sema/parentheses.c
@@ -5,7 +5,7 @@
 // Test the various warnings under -Wparentheses
 void if_assign(void) {
   int i;
-  if (i = 4) {} // expected-warning {{assignment as a condition}} \
+  if (i = 4) {} // expected-warning {{assignment as a truth value}} \
                 // expected-note{{place parentheses around the assignment to silence this warning}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}}
   // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:7-[[@LINE-3]]:7}:"("
@@ -118,4 +118,4 @@ void conditional_op(int x, int y, _Bool b, void* p) {
 }
 
 // RUN: not %clang_cc1 -fsyntax-only -Wparentheses -Werror %s 2>&1 | FileCheck %s -check-prefix=CHECK-FLAG
-// CHECK-FLAG: error: using the result of an assignment as a condition without parentheses [-Werror,-Wparentheses]
+// CHECK-FLAG: error: using the result of an assignment as a truth value without parentheses [-Werror,-Wparentheses]
diff --git a/clang/test/Sema/warn-assignment-bool-context.c b/clang/test/Sema/warn-assignment-bool-context.c
@@ -14,12 +14,12 @@ bool f3(bool x) { return x = 0; }
 void test() {
   int x;
 
-  // This should emit the `warn_condition_is_assignment` warning, since
+  // This should emit the `warn_assignment_bool_context` warning once, since
   // C doesn't do implicit conversion booleans for conditions.
-  if (x = 0) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = 0) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{place parentheses around the assignment to silence this warning}}\
                 // expected-note{{use '==' to turn this assignment into an equality comparison}}
-  if (x = 4 && x){} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = 4 && x){} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                     // expected-note{{place parentheses around the assignment to silence this warning}}\
                     // expected-note{{use '==' to turn this assignment into an equality comparison}}
 
diff --git a/clang/test/SemaCXX/warn-assignment-bool-context.cpp b/clang/test/SemaCXX/warn-assignment-bool-context.cpp
@@ -10,11 +10,11 @@ bool f3(bool x) { return x = 0; }
 void test() {
   int x;
 
-  // Assignments inside of conditions should still emit the more specific `warn_condition_is_assignment` warning.
-  if (x = 0) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  // Assignments inside of conditions should still emit the more specific `==` fixits.
+  if (x = 0) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
                 // expected-note{{place parentheses around the assignment to silence this warning}}
-  if (x = 4 && x){} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = 4 && x){} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                     // expected-note{{use '==' to turn this assignment into an equality comparison}} \
                     // expected-note{{place parentheses around the assignment to silence this warning}}
 
diff --git a/clang/test/SemaCXX/warn-assignment-condition.cpp b/clang/test/SemaCXX/warn-assignment-condition.cpp
@@ -12,41 +12,41 @@ void test() {
   A a, b;
 
   // With scalars.
-  if (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = 7) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   if ((x = 7)) {}
   do {
-  } while (x = 7); // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  } while (x = 7); // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   do {
   } while ((x = 7));
-  while (x = 7) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  while (x = 7) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
 
   while ((x = 7)) {}
-  for (; x = 7; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  for (; x = 7; ) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   for (; (x = 7); ) {}
 
-  if (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (p = p) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   if ((p = p)) {}
   do {
-  } while (p = p); // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  } while (p = p); // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   do {
   } while ((p = p));
-  while (p = p) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  while (p = p) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   while ((p = p)) {}
-  for (; p = p; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  for (; p = p; ) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   for (; (p = p); ) {}
@@ -58,51 +58,51 @@ void test() {
   while (A y = a) {}
 
   // With temporaries.
-  if (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   if ((x = (b+b).foo())) {}
   do {
-  } while (x = (b+b).foo()); // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  } while (x = (b+b).foo()); // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   do {
   } while ((x = (b+b).foo()));
-  while (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  while (x = (b+b).foo()) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   while ((x = (b+b).foo())) {}
-  for (; x = (b+b).foo(); ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  for (; x = (b+b).foo(); ) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   for (; (x = (b+b).foo()); ) {}
 
   // With a user-defined operator.
-  if (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (a = b + b) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   if ((a = b + b)) {}
   do {
-  } while (a = b + b); // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  } while (a = b + b); // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   do {
   } while ((a = b + b));
-  while (a = b + b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  while (a = b + b) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   while ((a = b + b)) {}
-  for (; a = b + b; ) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  for (; a = b + b; ) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '==' to turn this assignment into an equality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
   for (; (a = b + b); ) {}
 
   // Compound assignments.
-  if (x |= 2) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (x |= 2) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '!=' to turn this compound assignment into an inequality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
 
-  if (a |= b) {} // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (a |= b) {} // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                 // expected-note{{use '!=' to turn this compound assignment into an inequality comparison}} \
   // expected-note{{place parentheses around the assignment to silence this warning}}
 
diff --git a/clang/test/SemaObjC/idiomatic-parentheses.m b/clang/test/SemaObjC/idiomatic-parentheses.m
@@ -25,7 +25,7 @@ - (id) init {
 - (id) initWithInt: (int) i {
   if (self = [self initWithInt: i]) {
   }
-  if (self.uid = 100) { // expected-warning {{using the result of an assignment as a condition without parentheses}} \
+  if (self.uid = 100) { // expected-warning {{using the result of an assignment as a truth value without parentheses}} \
                         // expected-note {{place parentheses around the assignment to silence this warning}} \
                         // expected-note {{use '==' to turn this assignment into an equality comparison}}
         // ...
diff --git a/clang/test/SemaObjC/self-assign.m b/clang/test/SemaObjC/self-assign.m
@@ -5,7 +5,7 @@ @interface A
 @implementation A
 - (id):(int)x :(int)y {
     int z;
-    if (self = [self :x :y]) {} // expected-warning{{using the result of an assignment as a condition without parentheses}} \
+    if (self = [self :x :y]) {} // expected-warning{{using the result of an assignment as a truth value without parentheses}} \
     // expected-note{{use '==' to turn this assignment into an equality comparison}} \
     // expected-note{{place parentheses around the assignment to silence this warning}}
     return self;
diff --git a/clang/test/SemaOpenACC/compute-construct-if-clause.c b/clang/test/SemaOpenACC/compute-construct-if-clause.c
@@ -28,7 +28,7 @@ void BoolExpr(int *I, float *F) {
   while(0);
 
   // expected-warning@+4{{incompatible pointer types assigning to 'int *' from 'float *'}}
-  // expected-warning@+3{{using the result of an assignment as a condition without parentheses}}
+  // expected-warning@+3{{using the result of an assignment as a truth value without parentheses}}
   // expected-note@+2{{place parentheses around the assignment to silence this warning}}
   // expected-note@+1{{use '==' to turn this assignment into an equality comparison}}
 #pragma acc kernels if (I = F)

Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,15 @@ auto make_func() {`
`9`	`9`	`;`
`10`	`10`	`}`
`11`	`11`	`// Check that body of this function is actually skipped.`
`12`		`- // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a condition without parentheses`
	`12`	`+ // CHECK-NOT: crash-skipped-bodies-template-inst.cpp:7:{{[0-9]+}}: warning: using the result of an assignment as a truth value without parentheses`
`13`	`13`	`return this;`
`14`	`14`	`}`
`15`	`15`	`};`
`16`	`16`
`17`	`17`	`int x;`
`18`	`18`	`if (x = 10) {}`
`19`	`19`	`// Check that this function is not skipped.`
`20`		`- // CHECK: crash-skipped-bodies-template-inst.cpp:18:9: warning: using the result of an assignment as a condition without parentheses`
	`20`	`+ // CHECK: crash-skipped-bodies-template-inst.cpp:18:9: warning: using the result of an assignment as a truth value without parentheses`
`21`	`21`	`return impl();`
`22`	`22`	`}`
`23`	`23`