Skip to content

Commit e100161

Browse files
autoantwortclaude
autoantwort
and
claude
authored
Fix #15104 FP functionStatic and constParameterReference: call of overloaded member function template resolved to free function with the same name (#8936)
https://trac.cppcheck.net/ticket/15104 ```cpp struct DS; void select(int a, int b); class Query { int m = 0; public: template <typename Callback> int select(DS &ds, Callback cb) { cb(m); return 0; } template <typename Callback> int select(DS *ds, Callback cb) { return select(*ds, cb); } int select(DS &ds) { return select(ds, [](int) {}); } // FP functionStatic, constParameterReference }; ``` `Scope::findFunction()` couldn't choose between `select(DS &, Callback)` and `select(DS *, Callback)` for `select(ds, ...)` with `DS &ds`: the pointer overload stayed a candidate although an object can't be passed for a pointer to its class. As the call was ambiguous in the class scope, the lookup continued in the enclosing scopes and picked the free `select(int, int)`. A candidate is now removed when a plain variable argument and the parameter have the same class type but only one of them is a pointer: - an object for a `C*` parameter, unless the class (or one of its base classes, or an unknown base class) has a conversion operator - a `C*` for a non-const lvalue reference `C&` (a temporary from a converting constructor can bind to `const C&` and `C&&`, so these are kept) By-value parameters, arrays and function pointers/references are not affected. Incomplete types are assumed to have no conversion operator. Built-in and library types, and arguments that are not plain variables (`*p`), are not covered. When a member overload can't be resolved, the lookup still continues in the enclosing scopes although the member functions hide the free function (C++ name hiding). That is a separate issue and not changed here. This PR was created by Claude Code (an AI coding agent) on behalf of @autoantwort. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
1 parent 7bcaa49 commit e100161

4 files changed

Lines changed: 203 additions & 1 deletion

File tree

‎lib/symboldatabase.cpp‎

Lines changed: 43 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@
3939

4040
#include <algorithm>
4141
#include <cassert>
42+
#include <cctype>
4243
#include <cstring>
4344
#include <functional>
4445
#include <initializer_list>
@@ -5935,6 +5936,39 @@ std::vector<const Scope*> Scope::findAssociatedScopes() const
59355936

59365937
//---------------------------------------------------------------------------
59375938

5939+
// Might an object of the class be converted to a pointer by a conversion operator (also in an unknown base class)?
5940+
// operator C*(), operator ptr()
5941+
static bool mayConvertToPointer(const Scope* classScope)
5942+
{
5943+
const std::vector<const Scope*> scopes = classScope->findAssociatedScopes();
5944+
return std::any_of(scopes.cbegin(), scopes.cend(), [](const Scope* scope) {
5945+
const bool hasConversionOperator = std::any_of(scope->functionList.cbegin(), scope->functionList.cend(), [](const Function& f) {
5946+
return f.name().size() > 8 && startsWith(f.name(), "operator") &&
5947+
(std::isalpha(static_cast<unsigned char>(f.name()[8])) || f.name()[8] == '_' || f.name()[8] == ':');
5948+
});
5949+
const bool hasUnknownBase = scope->definedType && std::any_of(scope->definedType->derivedFrom.cbegin(), scope->definedType->derivedFrom.cend(), [](const Type::BaseInfo& base) {
5950+
return !base.type || !base.type->classScope;
5951+
});
5952+
return hasConversionOperator || hasUnknownBase;
5953+
});
5954+
}
5955+
5956+
// Returns true if the variable can't be passed for the function argument because only one of them is a pointer to
5957+
// the same class: struct C; void f(C* p); void g(C& r); C c; C* p; f(c); g(p);
5958+
static bool isPointerMismatch(const Variable* callarg, const Variable* funcarg)
5959+
{
5960+
if (!callarg->type() || callarg->type() != funcarg->type() || callarg->isArray() || funcarg->isArray())
5961+
return false;
5962+
// function pointer or reference: C (*f)()
5963+
if (Token::simpleMatch(callarg->nameToken()->next(), ") (") || (funcarg->nameToken() && Token::simpleMatch(funcarg->nameToken()->next(), ") (")))
5964+
return false;
5965+
// assume that incomplete types have no conversion operator
5966+
if (funcarg->isPointer())
5967+
return !callarg->isPointer() && (!callarg->type()->classScope || !mayConvertToPointer(callarg->type()->classScope));
5968+
// a temporary from a converting constructor can bind to const C& and C&&
5969+
return callarg->isPointer() && funcarg->isReference() && !funcarg->isRValueReference() && !funcarg->isConst();
5970+
}
5971+
59385972
static void checkVariableCallMatch(const Variable* callarg, const Variable* funcarg, size_t& same, size_t& fallback1, size_t& fallback2)
59395973
{
59405974
if (callarg) {
@@ -6070,7 +6104,7 @@ const Function* Scope::findFunction(const Token* tok, bool requireConst, Referen
60706104
addMatchingFunctions(nestedScope);
60716105
}
60726106

6073-
const std::size_t numberOfMatchesNonBase = matches.size();
6107+
std::size_t numberOfMatchesNonBase = matches.size();
60746108

60756109
// check in base classes
60766110
findFunctionInBase(name, tok, args, matches);
@@ -6184,6 +6218,14 @@ const Function* Scope::findFunction(const Token* tok, bool requireConst, Referen
61846218
// check for a match with a variable
61856219
if (Token::Match(arguments[j], "%var% ,|)")) {
61866220
const Variable * callarg = arguments[j]->variable();
6221+
if (callarg && isPointerMismatch(callarg, funcarg)) {
6222+
// can't match so remove this function from possible matches
6223+
matches.erase(matches.begin() + i);
6224+
if (i < numberOfMatchesNonBase)
6225+
--numberOfMatchesNonBase;
6226+
erased = true;
6227+
break;
6228+
}
61876229
checkVariableCallMatch(callarg, funcarg, same, fallback1, fallback2);
61886230
}
61896231

‎test/testclass.cpp‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -200,6 +200,7 @@ class TestClass : public TestFixture {
200200
TEST_CASE(const101);
201201
TEST_CASE(const102);
202202
TEST_CASE(const103);
203+
TEST_CASE(const104); // #15104
203204

204205
TEST_CASE(const_handleDefaultParameters);
205206
TEST_CASE(const_passThisToMemberOfOtherClass);
@@ -7067,6 +7068,21 @@ class TestClass : public TestFixture {
70677068
ASSERT_EQUALS("", errout_str());
70687069
}
70697070

7071+
void const104() { // #15104
7072+
checkConst("struct DS;\n"
7073+
"void select(int a, int b);\n"
7074+
"class Query {\n"
7075+
" int m = 0;\n"
7076+
"public:\n"
7077+
" template <typename Callback>\n"
7078+
" int select(DS &ds, Callback cb) { cb(m); return 0; }\n"
7079+
" template <typename Callback>\n"
7080+
" int select(DS *ds, Callback cb) { return select(*ds, cb); }\n"
7081+
" int select(DS &ds) { return select(ds, [](int) {}); }\n"
7082+
"};\n");
7083+
ASSERT_EQUALS("", errout_str());
7084+
}
7085+
70707086
void const_handleDefaultParameters() {
70717087
checkConst("struct Foo {\n"
70727088
" void foo1(int i, int j = 0) {\n"

‎test/testother.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4213,6 +4213,18 @@ class TestOther : public TestFixture {
42134213
" }\n"
42144214
"}\n");
42154215
ASSERT_EQUALS("", errout_str());
4216+
4217+
check("struct DS;\n" // #15104
4218+
"void select(int a, int b);\n"
4219+
"class Query {\n"
4220+
"public:\n"
4221+
" template <typename Callback>\n"
4222+
" int select(DS &ds, Callback cb);\n"
4223+
" template <typename Callback>\n"
4224+
" int select(DS *ds, Callback cb);\n"
4225+
" int select(DS &ds) { return select(ds, [](int) {}); }\n"
4226+
"};\n");
4227+
ASSERT_EQUALS("", errout_str());
42164228
}
42174229

42184230
void constParameterCallback() {

‎test/testsymboldatabase.cpp‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -547,6 +547,7 @@ class TestSymbolDatabase : public TestFixture {
547547
TEST_CASE(findFunction63); // #14937 - member function of type returned by operator()
548548
TEST_CASE(findFunction64); // overloaded operator()
549549
TEST_CASE(findFunction65);
550+
TEST_CASE(findFunction66); // #15104 - object passed for pointer to its class
550551
TEST_CASE(findFunctionRef1);
551552
TEST_CASE(findFunctionRef2); // #13328
552553
TEST_CASE(findFunctionContainer);
@@ -9005,6 +9006,137 @@ class TestSymbolDatabase : public TestFixture {
90059006
}
90069007
}
90079008

9009+
void findFunction66() { // #15104 - object passed for pointer to its class
9010+
{
9011+
GET_SYMBOL_DB("struct DS;\n"
9012+
"void select(int a, int b);\n"
9013+
"class Query {\n"
9014+
" int m = 0;\n"
9015+
"public:\n"
9016+
" template <typename Callback>\n"
9017+
" int select(DS &ds, Callback cb) { cb(m); return 0; }\n"
9018+
" template <typename Callback>\n"
9019+
" int select(DS *ds, Callback cb) { return select(*ds, cb); }\n"
9020+
" int select(DS &ds) { return select(ds, [](int) {}); }\n"
9021+
"};\n");
9022+
const Token* call1 = Token::findsimplematch(tokenizer.tokens(), "select ( * ds , cb )");
9023+
ASSERT(call1 && call1->function());
9024+
ASSERT_EQUALS(7, call1->function()->tokenDef->linenr());
9025+
const Token* call2 = Token::findsimplematch(tokenizer.tokens(), "select ( ds , [");
9026+
ASSERT(call2 && call2->function());
9027+
ASSERT_EQUALS(7, call2->function()->tokenDef->linenr());
9028+
}
9029+
{
9030+
GET_SYMBOL_DB("struct DS;\n"
9031+
"void select(int a, int b);\n"
9032+
"struct Base {\n"
9033+
" int m = 0;\n"
9034+
" template <typename Callback>\n"
9035+
" int select(DS &ds, Callback cb) { cb(m); return 0; }\n"
9036+
" template <typename Callback>\n"
9037+
" int select(DS *ds, Callback cb) { return select(*ds, cb); }\n"
9038+
"};\n"
9039+
"struct Query : Base {\n"
9040+
" int run(DS &ds) { return select(ds, [](int) {}); }\n"
9041+
"};\n");
9042+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "select ( ds , [");
9043+
ASSERT(call && call->function());
9044+
ASSERT_EQUALS(6, call->function()->tokenDef->linenr());
9045+
}
9046+
{
9047+
GET_SYMBOL_DB("struct DS;\n"
9048+
"void select(int a, int b);\n"
9049+
"namespace N {\n"
9050+
" template <typename C> int select(DS &ds, C cb) { cb(1); return 0; }\n"
9051+
" template <typename C> int select(DS *ds, C cb) { return select(*ds, cb); }\n"
9052+
" int f(DS &ds) { return select(ds, [](int) {}); }\n"
9053+
"}\n");
9054+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "select ( ds , [");
9055+
ASSERT(call && call->function());
9056+
ASSERT_EQUALS(4, call->function()->tokenDef->linenr());
9057+
}
9058+
{ // conversion operator
9059+
GET_SYMBOL_DB("struct C { operator C*(); };\n"
9060+
"void f(C* p);\n"
9061+
"void g(C c) { f(c); }\n");
9062+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "f ( c )");
9063+
ASSERT(call && call->function());
9064+
ASSERT_EQUALS(2, call->function()->tokenDef->linenr());
9065+
}
9066+
{ // converting constructor
9067+
GET_SYMBOL_DB("struct N { N(N* parent); };\n"
9068+
"void f(N&& n);\n"
9069+
"void g(const N& n);\n"
9070+
"void h(N* p) { f(p); g(p); }\n");
9071+
const Token* call1 = Token::findsimplematch(tokenizer.tokens(), "f ( p )");
9072+
ASSERT(call1 && call1->function());
9073+
ASSERT_EQUALS(2, call1->function()->tokenDef->linenr());
9074+
const Token* call2 = Token::findsimplematch(tokenizer.tokens(), "g ( p )");
9075+
ASSERT(call2 && call2->function());
9076+
ASSERT_EQUALS(3, call2->function()->tokenDef->linenr());
9077+
}
9078+
{ // function reference
9079+
GET_SYMBOL_DB("struct C { int x; };\n"
9080+
"C make();\n"
9081+
"void reg(C (*f)());\n"
9082+
"void g() { C (&fr)() = make; reg(fr); }\n");
9083+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "reg ( fr )");
9084+
ASSERT(call && call->function());
9085+
ASSERT_EQUALS(3, call->function()->tokenDef->linenr());
9086+
}
9087+
{ // conversion operator in base class or with type alias
9088+
GET_SYMBOL_DB("template <class D> struct PtrConv { operator D*(); };\n"
9089+
"struct C : PtrConv<C> {};\n"
9090+
"struct F { using ptr = F*; operator ptr(); };\n"
9091+
"void f(C* p);\n"
9092+
"void k(F* p);\n"
9093+
"void g(C c, F e) { f(c); k(e); }\n");
9094+
const Token* call1 = Token::findsimplematch(tokenizer.tokens(), "f ( c )");
9095+
ASSERT(call1 && call1->function());
9096+
ASSERT_EQUALS(4, call1->function()->tokenDef->linenr());
9097+
const Token* call2 = Token::findsimplematch(tokenizer.tokens(), "k ( e )");
9098+
ASSERT(call2 && call2->function());
9099+
ASSERT_EQUALS(5, call2->function()->tokenDef->linenr());
9100+
}
9101+
{ // conversion operator in unknown base class or to qualified type
9102+
GET_SYMBOL_DB("struct C : Unknown { int x; };\n"
9103+
"struct D { operator ::D*(); };\n"
9104+
"void f(C* p);\n"
9105+
"void k(D* p);\n"
9106+
"void g(C c, D d) { f(c); k(d); }\n");
9107+
const Token* call1 = Token::findsimplematch(tokenizer.tokens(), "f ( c )");
9108+
ASSERT(call1 && call1->function());
9109+
ASSERT_EQUALS(3, call1->function()->tokenDef->linenr());
9110+
const Token* call2 = Token::findsimplematch(tokenizer.tokens(), "k ( d )");
9111+
ASSERT(call2 && call2->function());
9112+
ASSERT_EQUALS(4, call2->function()->tokenDef->linenr());
9113+
}
9114+
{ // pointer passed for non-const reference
9115+
GET_SYMBOL_DB("struct C { int x; };\n"
9116+
"void f(int a, int b);\n"
9117+
"namespace N {\n"
9118+
" template <class T> void f(C& r, T t);\n"
9119+
" template <class T> void f(C* p, T t);\n"
9120+
" void h(C* p) { f(p, 1); }\n"
9121+
"}\n");
9122+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "f ( p , 1 )");
9123+
ASSERT(call && call->function());
9124+
ASSERT_EQUALS(5, call->function()->tokenDef->linenr());
9125+
}
9126+
{ // removed candidate must not change name hiding of base class functions
9127+
GET_SYMBOL_DB("struct C { int x; };\n"
9128+
"struct Base { void f(const C& r, int i) const; };\n"
9129+
"struct Derived : Base {\n"
9130+
" void f(C* p, int i);\n"
9131+
" void f(C& r, double v);\n"
9132+
" void g(C& c) { f(c, 1); }\n"
9133+
"};\n");
9134+
const Token* call = Token::findsimplematch(tokenizer.tokens(), "f ( c , 1 )");
9135+
ASSERT(call && call->function());
9136+
ASSERT_EQUALS(5, call->function()->tokenDef->linenr());
9137+
}
9138+
}
9139+
90089140
void findFunctionRef1() {
90099141
GET_SYMBOL_DB("struct X {\n"
90109142
" const std::vector<int> getInts() const & { return mInts; }\n"

0 commit comments

Comments
 (0)