From 543cb655b174087f6c2d22009934c9fed6c32114 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Thu, 17 Feb 2011 08:37:06 +0000 Subject: [PATCH] Implement -Wenum-compare, which warns when comparing two enums of different types. We omit the warning when the enum types are anonymous. Unlike GCC, this warning does not distinguish between C++ and C/ObjC for controling whether it is on by default, it is always on by default. Original patch contributed by Richard Trieu (@ Google), I fixed some style issues, and cleaned it up for submission. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@125739 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/DiagnosticSemaKinds.td | 3 + lib/Sema/SemaExpr.cpp | 20 +- test/SemaCXX/overloaded-operator.cpp | 4 +- test/SemaCXX/warn-enum-compare.cpp | 212 +++++++++++++++++++++ 4 files changed, 235 insertions(+), 4 deletions(-) create mode 100644 test/SemaCXX/warn-enum-compare.cpp diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index b815426f6c..985a771028 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -2514,6 +2514,9 @@ def warn_lunsigned_always_true_comparison : Warning< def warn_runsigned_always_true_comparison : Warning< "comparison of %0 unsigned%select{| enum}2 expression is always %1">, InGroup; +def warn_comparison_of_mixed_enum_types : Warning< + "comparison of two values with different enumeration types (%0 and %1)">, + InGroup>; def err_invalid_this_use : Error< "invalid use of 'this' outside of a nonstatic member function">; diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp index 94dd27d0c2..052dd4b956 100644 --- a/lib/Sema/SemaExpr.cpp +++ b/lib/Sema/SemaExpr.cpp @@ -6637,6 +6637,24 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, QualType lType = lex->getType(); QualType rType = rex->getType(); + Expr *LHSStripped = lex->IgnoreParenImpCasts(); + Expr *RHSStripped = rex->IgnoreParenImpCasts(); + QualType LHSStrippedType = LHSStripped->getType(); + QualType RHSStrippedType = RHSStripped->getType(); + + // Two different enums will raise a warning when compared. + if (const EnumType *LHSEnumType = LHSStrippedType->getAs()) { + if (const EnumType *RHSEnumType = RHSStrippedType->getAs()) { + if (LHSEnumType->getDecl()->getIdentifier() && + RHSEnumType->getDecl()->getIdentifier() && + !Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) { + Diag(Loc, diag::warn_comparison_of_mixed_enum_types) + << LHSStrippedType << RHSStrippedType + << lex->getSourceRange() << rex->getSourceRange(); + } + } + } + if (!lType->hasFloatingRepresentation() && !(lType->isBlockPointerType() && isRelational) && !lex->getLocStart().isMacroID() && @@ -6651,8 +6669,6 @@ QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, // obvious cases in the definition of the template anyways. The idea is to // warn when the typed comparison operator will always evaluate to the same // result. - Expr *LHSStripped = lex->IgnoreParenImpCasts(); - Expr *RHSStripped = rex->IgnoreParenImpCasts(); if (DeclRefExpr* DRL = dyn_cast(LHSStripped)) { if (DeclRefExpr* DRR = dyn_cast(RHSStripped)) { if (DRL->getDecl() == DRR->getDecl() && diff --git a/test/SemaCXX/overloaded-operator.cpp b/test/SemaCXX/overloaded-operator.cpp index a9d3f128e2..4399a026ea 100644 --- a/test/SemaCXX/overloaded-operator.cpp +++ b/test/SemaCXX/overloaded-operator.cpp @@ -70,11 +70,11 @@ struct E2 { // C++ [over.match.oper]p3 - enum restriction. float& operator==(E1, E2); -void enum_test(Enum1 enum1, Enum2 enum2, E1 e1, E2 e2) { +void enum_test(Enum1 enum1, Enum2 enum2, E1 e1, E2 e2, Enum1 next_enum1) { float &f1 = (e1 == e2); float &f2 = (enum1 == e2); float &f3 = (e1 == enum2); - float &f4 = (enum1 == enum2); // expected-error{{non-const lvalue reference to type 'float' cannot bind to a temporary of type 'bool'}} + float &f4 = (enum1 == next_enum1); // expected-error{{non-const lvalue reference to type 'float' cannot bind to a temporary of type 'bool'}} } // PR5244 - Argument-dependent lookup would include the two operators below, diff --git a/test/SemaCXX/warn-enum-compare.cpp b/test/SemaCXX/warn-enum-compare.cpp new file mode 100644 index 0000000000..52639e70a8 --- /dev/null +++ b/test/SemaCXX/warn-enum-compare.cpp @@ -0,0 +1,212 @@ +// RUN: %clang_cc1 %s -fsyntax-only -verify + +enum Foo { FooA, FooB, FooC }; +enum Bar { BarD, BarE, BarF }; +enum { AnonAA = 42, AnonAB = 43 }; +enum { AnonBA = 44, AnonBB = 45 }; + +namespace name1 { + enum Foo {F1, F2, F3}; + enum Baz {B1, B2, B3}; +} + +namespace name2 { + enum Baz {B1, B2, B3}; +} + +using name1::Baz; +using name1::B1; +using name2::B2; +typedef name1::Foo oneFoo; +typedef name1::Foo twoFoo; +Foo getFoo(); +Bar getBar(); + +void test () { + Foo x = FooA; + Bar y = BarD; + Baz z = name1::B3; + name1::Foo a; + oneFoo b; + twoFoo c; + + while (x == FooA); + while (y == BarD); + while (a == name1::F1); + while (z == name1::B2); + while (a == b); + while (a == c); + while (b == c); + while (B1 == name1::B2); + while (B2 == name2::B1); + while (x == AnonAA); + while (AnonBB == y); + while (AnonAA == AnonAB); + while (AnonAB == AnonBA); + while (AnonBB == AnonAA); + + while ((x) == FooA); + while ((y) == BarD); + while ((a) == name1::F1); + while (z == (name1::B2)); + while (a == (b)); + while (a == (c)); + while ((b) == (c)); + while ((B1) == (name1::B2)); + while ((B2) == (name2::B1)); + + while (((x)) == FooA); + while ((y) == (BarD)); + while ((a) == (name1::F1)); + while (z == (name1::B2)); + while ((a) == ((((b))))); + while (((a)) == (c)); + while ((b) == (((c)))); + while ((((((B1))))) == (((name1::B2)))); + while (B2 == ((((((name2::B1))))))); + + while (B1 == B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (name1::B2 == name2::B3); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (z == name2::B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while (((((B1)))) == B2); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (name1::B2 == (name2::B3)); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while (z == ((((name2::B2))))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while ((((B1))) == (((B2)))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while ((name1::B2) == (((name2::B3)))); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + while ((((z))) == (name2::B2)); // expected-warning {{comparison of two values with different enumeration types ('name1::Baz' and 'name2::Baz')}} + + while (x == a); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'name1::Foo')}} + while (x == b); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'oneFoo' (aka 'name1::Foo'))}} + while (x == c); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'twoFoo' (aka 'name1::Foo'))}} + + while (x == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (x == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < y); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < BarD); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (getFoo() == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (getFoo() < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (FooB == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (FooB < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + while (x == getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x != getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x >= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x <= getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x > getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + while (x < getBar()); // expected-warning {{comparison of two values with different enumeration types ('Foo' and 'Bar')}} + + + + while (y == x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (y == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (BarD == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD = x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD < x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > x); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (y == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (y < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (BarD == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (BarD < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (getBar() == getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() != getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() >= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() <= getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() > getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() < getFoo()); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + + while (getBar() == FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() != FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() >= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() <= FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() > FooB); // expected-warning {{comparison of two values with different enumeration types ('Bar' and 'Foo')}} + while (getBar() < FooB); // 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')}} + 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')}} + +} -- 2.40.0