[Sema] Assign new flag -Wenum-compare-switch to switch-related parts of -Wenum-compare

[rnkovacs]

Summary

This patch assigns switch-related parts of the -Wenum-compare diagnostic to a new flag -Wenum-compare-switch.

-Wenum-compare-switch is put into the same group as -Wenum-compare so that -W(no-)enum-compare affects both.

[aaron.ballman]

LGTM

[thakis]

Thanks!

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

 def : DiagGroup<"strict-prototypes">;
 def StrictSelector : DiagGroup<"strict-selector-match">;
 def MethodDuplicate : DiagGroup<"duplicate-method-match">;
 def ObjCCStringFormat : DiagGroup<"cstring-format-directive">;
 def CoveredSwitchDefault : DiagGroup<"covered-switch-default">;
 def SwitchBool     : DiagGroup<"switch-bool">;
 def SwitchEnum     : DiagGroup<"switch-enum">;
 def Switch         : DiagGroup<"switch">;
+def EnumCompareSwitch : DiagGroup<"enum-compare-switch">;
+def EnumCompare       : DiagGroup<"enum-compare", [EnumCompareSwitch]>;
 def ImplicitFallthroughPerFunction :
   DiagGroup<"implicit-fallthrough-per-function">;
 def ImplicitFallthrough  : DiagGroup<"implicit-fallthrough",
                                      [ImplicitFallthroughPerFunction]>;
 def InvalidPPToken : DiagGroup<"invalid-pp-token">;
 def Trigraphs      : DiagGroup<"trigraphs">;
 
 def : DiagGroup<"type-limits">;

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

def warn_out_of_range_compare : Warning<
   "%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>;
 def warn_comparison_of_mixed_enum_types : Warning<
   "comparison of two values with different enumeration types"
   "%diff{ ($ and $)|}0,1">,
-  InGroup<DiagGroup<"enum-compare">>;
+  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>;
 def warn_null_in_arithmetic_operation : Warning<
   "use of NULL in arithmetic operation">,
   InGroup<NullArithmetic>;
 def warn_null_in_comparison_operation : Warning<
   "comparison between NULL and non-pointer "
   "%select{(%1 and NULL)|(NULL and %1)}0">,
   InGroup<NullArithmetic>;
 def err_shift_rhs_only_vector : Error<

cfe/trunk/lib/Sema/SemaStmt.cpp

static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond,
   if (!CondEnumType->getDecl()->getIdentifier())
     return;
   if (!CaseEnumType->getDecl()->getIdentifier())
     return;
 
   if (S.Context.hasSameUnqualifiedType(CondType, CaseType))
     return;
 
-  S.Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types)
+  S.Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
       << CondType << CaseType << Cond->getSourceRange()
       << Case->getSourceRange();
 }
 
 StmtResult
 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
                             Stmt *BodyStmt) {
   SwitchStmt *SS = cast<SwitchStmt>(Switch);

cfe/trunk/test/Sema/switch.c

 static const enum ExtendedEnum1_unrelated EE1_d = 101;
 
 void switch_on_ExtendedEnum1(enum ExtendedEnum1 e) {
   switch(e) {
   case EE1_a: break;
   case EE1_b: break;
   case EE1_c: break; // no-warning
   case EE1_d: break; // expected-warning {{case value not in enumerated type 'enum ExtendedEnum1'}}
-  // expected-warning@-1 {{comparison of two values with different enumeration types ('enum ExtendedEnum1' and 'const enum ExtendedEnum1_unrelated')}}
+  // expected-warning@-1 {{comparison of two values with different enumeration types in switch statement ('enum ExtendedEnum1' and 'const enum ExtendedEnum1_unrelated')}}
   }
 }
 
 void PR11778(char c, int n, long long ll) {
   // Do not reject this; we don't have duplicate case values because we
   // check for duplicates in the promoted type.
   switch (c) case 1: case 257: ; // expected-warning {{overflow}}
 
   switch (n) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
   switch ((int)ll) case 0x100000001LL: case 1: ; // expected-warning {{overflow}} expected-error {{duplicate}} expected-note {{previous}}
   switch ((long long)n) case 0x100000001LL: case 1: ;
   switch (ll) case 0x100000001LL: case 1: ;
 }

cfe/trunk/test/SemaCXX/warn-enum-compare.cpp

void test () {
   while (getBar() >= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
   while (getBar() <= x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
   while (getBar() > x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
   while (getBar() < x); // expected-warning  {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
 
   switch (a) {
     case name1::F1: break;
     case name1::F3: break;
-    case name2::B2: break; // expected-warning {{comparison of two values with different enumeration types ('name1::Foo' and 'name2::Baz')}}
+    case name2::B2: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('name1::Foo' and 'name2::Baz')}}
   }
 
   switch (x) {
     case FooB: break;
     case FooC: break;
-    case BarD: break; // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}}
+    case BarD: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('Foo' and 'Bar')}}
   }
 
   switch(getBar()) {
     case BarE: break;
     case BarF: break;
-    case FooA: break; // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}}
+    case FooA: break; // expected-warning {{comparison of two values with different enumeration types in switch statement ('Bar' and 'Foo')}}
   }
 
   switch(x) {
     case AnonAA: break; // expected-warning {{case value not in enumerated type 'Foo'}}
     case FooA: break;
     case FooB: break;
     case FooC: break;
   }
 }