[Sema] Put tautological comparison of unsigned and zero into it's own flag

[lebedev.ri]

Summary

As requested by Sam McCall.

$ /build/llvm-build-Clang-release/./bin/clang -c /build/clang/test/Sema/outof-range-constant-compare.c /build/clang/test/Sema/outof-range-constant-compare.c:40:11: warning: comparison of unsigned expression < 0 is always false [-Wtautological-unsigned-zero-compare]
    if (a < 0x0000000000000000UL) // expected-warning {{comparison of unsigned expression < 0 is always false}}
        ~ ^ ~~~~~~~~~~~~~~~~~~~~

[aaron.ballman]

Does this need test?

Yes, it does -- I'd add one with two RUN lines, one with the flag and one without it to make sure you only get the diagnostics in one case.

[sammccall]

Thanks!
Unless I'm missing something, the current patch just adds the category, but doesn't actually recategorize the warning, right?

[aaron.ballman]

In D37620#864684, @sammccall wrote:

Thanks!
Unless I'm missing something, the current patch just adds the category, but doesn't actually recategorize the warning, right?

The diagnostics in DiagnosticSemaKinds.td are changed to be in the new group.

[sammccall]

Right, of course.

Thanks and LG, but clearly also get a review from someone more familiar with the code (I'm just a buildcop)

[aaron.ballman]

The bulk of the patch LGTM as well, but it should still have a test case.

[lebedev.ri]

Added test.

[aaron.ballman]

Please run the test through clang-format, but otherwise LGTM!

cfe/trunk/include/clang/Basic/DiagnosticGroups.td

 def StaticLocalInInline : DiagGroup<"static-local-in-inline">;
 def GNUStaticFloatInit : DiagGroup<"gnu-static-float-init">;
 def StaticFloatInit : DiagGroup<"static-float-init", [GNUStaticFloatInit]>;
 def GNUStatementExpression : DiagGroup<"gnu-statement-expression">;
 def StringCompare : DiagGroup<"string-compare">;
 def StringPlusInt : DiagGroup<"string-plus-int">;
 def StringPlusChar : DiagGroup<"string-plus-char">;
 def StrncatSize : DiagGroup<"strncat-size">;
+def TautologicalUnsignedZeroCompare : DiagGroup<"tautological-unsigned-zero-compare">;
 def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">;
 def TautologicalPointerCompare : DiagGroup<"tautological-pointer-compare">;
 def TautologicalOverlapCompare : DiagGroup<"tautological-overlap-compare">;
 def TautologicalUndefinedCompare : DiagGroup<"tautological-undefined-compare">;
 def TautologicalCompare : DiagGroup<"tautological-compare",
-                                    [TautologicalOutOfRangeCompare,
+                                    [TautologicalUnsignedZeroCompare,
+                                     TautologicalOutOfRangeCompare,
                                      TautologicalPointerCompare,
                                      TautologicalOverlapCompare,
                                      TautologicalUndefinedCompare]>;
 def HeaderHygiene : DiagGroup<"header-hygiene">;
 def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">;
 def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">;
 def GNUUnionCast : DiagGroup<"gnu-union-cast">;
 def GNUVariableSizedTypeNotAtEnd : DiagGroup<"gnu-variable-sized-type-not-at-end">;

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def note_typecheck_assign_const : Note<
   "%select{non-|}1static data member %2 declared const here|"
   "member function %q1 is declared const here}0">;
 
 def warn_mixed_sign_comparison : Warning<
   "comparison of integers of different signs: %0 and %1">,
   InGroup<SignCompare>, DefaultIgnore;
 def warn_lunsigned_always_true_comparison : Warning<
   "comparison of unsigned%select{| enum}2 expression %0 is always %1">,
-  InGroup<TautologicalCompare>;
+  InGroup<TautologicalUnsignedZeroCompare>;
 def warn_out_of_range_compare : Warning<
   "comparison of %select{constant %0|true|false}1 with " 
   "%select{expression of type %2|boolean expression}3 is always "
   "%select{false|true}4">, InGroup<TautologicalOutOfRangeCompare>;
 def warn_runsigned_always_true_comparison : Warning<
   "comparison of %0 unsigned%select{| enum}2 expression is always %1">,
-  InGroup<TautologicalCompare>;
+  InGroup<TautologicalUnsignedZeroCompare>;
 def warn_comparison_of_mixed_enum_types : Warning<
   "comparison of two values with different enumeration types"
   "%diff{ ($ and $)|}0,1">,
   InGroup<EnumCompare>;
 def warn_comparison_of_mixed_enum_types_switch : Warning<
   "comparison of two values with different enumeration types in switch statement"
   "%diff{ ($ and $)|}0,1">,
   InGroup<EnumCompareSwitch>;

cfe/trunk/test/Sema/tautological-unsigned-zero-compare.c

+// RUN: %clang_cc1 -fsyntax-only -DTEST -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wno-tautological-unsigned-zero-compare -verify %s
+
+unsigned value(void);
+
+int main() {
+  unsigned un = value();
+
+#ifdef TEST
+  if (un < 0) // expected-warning {{comparison of unsigned expression < 0 is always false}}
+    return 0;
+  if (un >= 0) // expected-warning {{comparison of unsigned expression >= 0 is always true}}
+    return 0;
+  if (0 <= un) // expected-warning {{comparison of 0 <= unsigned expression is always true}}
+    return 0;
+  if (0 > un) // expected-warning {{comparison of 0 > unsigned expression is always false}}
+    return 0;
+  if (un < 0U) // expected-warning {{comparison of unsigned expression < 0 is always false}}
+    return 0;
+  if (un >= 0U) // expected-warning {{comparison of unsigned expression >= 0 is always true}}
+    return 0;
+  if (0U <= un) // expected-warning {{comparison of 0 <= unsigned expression is always true}}
+    return 0;
+  if (0U > un) // expected-warning {{comparison of 0 > unsigned expression is always false}}
+    return 0;
+#else
+// expected-no-diagnostics
+  if (un < 0)
+    return 0;
+  if (un >= 0)
+    return 0;
+  if (0 <= un)
+    return 0;
+  if (0 > un)
+    return 0;
+  if (un < 0U)
+    return 0;
+  if (un >= 0U)
+    return 0;
+  if (0U <= un)
+    return 0;
+  if (0U > un)
+    return 0;
+#endif
+
+  return 1;
+}