From 04559a79415e813283ddfbb8cdfdde5620c95f3b Mon Sep 17 00:00:00 2001 From: Aaron Ballman Date: Wed, 30 Jul 2014 23:50:53 +0000 Subject: [PATCH] Updating a comment related to the implementation of -Woverloaded-virtual, and adding a FIXME to a test case. (Drive-by removal of trailing whitespace in the test case as well.) No functional changes. llvm-svn: 214362 --- clang/lib/Sema/SemaDeclCXX.cpp | 9 ++++++++- clang/test/SemaCXX/warn-overloaded-virtual.cpp | 22 ++++++++++++++++++++-- 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index c5cd83d..8a760a8 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -5945,7 +5945,14 @@ static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier, if (!MD->isVirtual()) continue; // If the method we are checking overrides a method from its base - // don't warn about the other overloaded methods. + // don't warn about the other overloaded methods. Clang deviates from GCC + // by only diagnosing overloads of inherited virtual functions that do not + // override any other virtual functions in the base. GCC's + // -Woverloaded-virtual diagnoses any derived function hiding a virtual + // function from a base class. These cases may be better served by a + // warning (not specific to virtual functions) on call sites when the call + // would select a different function from the base class, were it visible. + // See FIXME in test/SemaCXX/warn-overload-virtual.cpp for an example. if (!Data.S->IsOverload(Data.Method, MD, false)) return true; // Collect the overload only if its hidden. diff --git a/clang/test/SemaCXX/warn-overloaded-virtual.cpp b/clang/test/SemaCXX/warn-overloaded-virtual.cpp index 629d59d..6204826 100644 --- a/clang/test/SemaCXX/warn-overloaded-virtual.cpp +++ b/clang/test/SemaCXX/warn-overloaded-virtual.cpp @@ -48,8 +48,8 @@ struct Base { void Base::foo(int) { } struct Derived : public Base { - virtual void foo(int); - void foo(int, int); + virtual void foo(int); + void foo(int, int); }; } @@ -138,3 +138,21 @@ namespace { // expected-warning@-1{{hides overloaded virtual functions}} }; } + +namespace { +struct base { + void f(char) {} +}; + +struct derived : base { + void f(int) {} +}; + +void foo(derived &d) { + d.f('1'); // FIXME: this should warn about calling (anonymous namespace)::derived::f(int) + // instead of (anonymous namespace)::base::f(char). + // Note: this should be under a new diagnostic flag and eventually moved to a + // new test case since it's not strictly related to virtual functions. + d.f(12); // This should not warn. +} +} -- 2.7.4