Handle overloading better

Author: Your Name

lib/templatesimplifier.cpp

@@ -848,12 +848,21 @@ namespace {
 
     class DeductionSymbolTable;
 
+    // a function template declaration that a call could instantiate,
+    // together with its template type parameters
+    struct DeductionCandidate {
+        const TemplateSimplifier::TokenAndName *declaration;
+        std::vector<const Token *> templateParams;
+    };
+
     // Token keyword flags are not set yet when templates are simplified so
     // keywords are recognized by their string.
     struct DeductionContext {
         const Settings &settings;
         const TokenList &tokenList;
         const DeductionSymbolTable &symbols;
+        // the function templates, by name
+        const std::multimap<std::string, DeductionCandidate> &templateFunctions;
 
         // is |tok| a name that can be a user defined identifier?
         bool isIdentifier(const Token *tok) const {
@@ -1312,7 +1321,8 @@ namespace {
             // the walk can record a declaration twice (class members are
             // recorded up front and again when the body is walked)
             if (std::none_of(declarations.cbegin(), declarations.cend(), [&](const ParsedType &declaration) {
-                return sameDeducedType(declaration.type, returnType.type);
+                return (!declaration.type.valid && !returnType.type.valid) ||
+                       sameDeducedType(declaration.type, returnType.type);
             }))
                 declarations.push_back(returnType);
         }
@@ -1341,6 +1351,23 @@ namespace {
             return false;
         }
 
+        // is a (non template) function with this name visible?
+        bool hasFunction(const std::string &name) const {
+            for (auto scope = mScopes.crbegin(); scope != mScopes.crend(); ++scope) {
+                if (scope->members.functions.find(name) != scope->members.functions.cend())
+                    return true;
+                if (scope->memberClass.empty())
+                    continue;
+                for (const std::string &className : withBaseClasses(scope->memberClass)) {
+                    const auto classIt = mClassMembers.find(className);
+                    if (classIt != mClassMembers.cend() &&
+                        classIt->second.functions.find(name) != classIt->second.functions.cend())
+                        return true;
+                }
+            }
+            return false;
+        }
+
         // all visible declarations of the function must agree on the return type
         bool lookupFunctionReturnType(const std::string &name, ParsedType &result) const {
             bool found = false;
@@ -1574,8 +1601,12 @@ static ExprType parseOperandType(const DeductionContext &ctx, const Token *&tok,
             return ExprType();
     } else if (ctx.isIdentifier(tok)) {
         if (tok->next() != end && Token::simpleMatch(tok->next(), "(")) {
-            // function call
+            // function call: the return type of the visible declarations.
+            // When the name is also a function template the call could
+            // resolve to an instantiation with another return type.
             ParsedType returnType;
+            if (ctx.templateFunctions.count(tok->str()) != 0)
+                return ExprType();
             if (!ctx.symbols.lookupFunctionReturnType(tok->str(), returnType))
                 return ExprType();
             if (!tok->next()->link())
@@ -1784,15 +1815,6 @@ static bool deduceTemplateArgumentFromParam(const ParsedType &param, const ExprT
     return renderDeducedType(type, keepTopConst, tokens);
 }
 
-namespace {
-    // a function template declaration that a call could instantiate,
-    // together with its template type parameters
-    struct DeductionCandidate {
-        const TemplateSimplifier::TokenAndName *declaration;
-        std::vector<const Token *> templateParams;
-    };
-}
-
 // Deduce the template arguments of the function template call at |tok| from
 // the argument types and insert the explicit "< ... >" tokens after the
 // function name when the deduction succeeds.
@@ -1978,8 +2000,14 @@ static void recordDeclaration(const DeductionContext &ctx, DeductionSymbolTable
         const Token *rpar = tok->next()->link();
         if (Token::Match(rpar->next(), ";|{|const|noexcept")) {
             const Token *start = findDeclarationTypeStart(ctx, tok);
-            if (start && parseType(ctx, start, tok, parsed) == tok && parsed.type.valid)
-                symbols.addFunction(tok->str(), parsed);
+            if (start) {
+                if (parseType(ctx, start, tok, parsed) == tok && parsed.type.valid)
+                    symbols.addFunction(tok->str(), parsed);
+                else
+                    // unsupported return type ("void" etc): record that the
+                    // function exists but that its type is not known
+                    symbols.addFunction(tok->str(), ParsedType());
+            }
         }
     }
 }
@@ -2031,7 +2059,7 @@ void TemplateSimplifier::deduceFunctionTemplateArguments()
     // during the walk so that at every call site the declarations that are
     // visible there - and only those - can be looked up by name.
     DeductionSymbolTable symbols;
-    const DeductionContext ctx = { mSettings, mTokenList, symbols };
+    const DeductionContext ctx = { mSettings, mTokenList, symbols, functionNameMap };
 
     // the body of the class definition that is about to start
     const Token *classBodyStart = nullptr;
@@ -2138,9 +2166,13 @@ void TemplateSimplifier::deduceFunctionTemplateArguments()
             if (tok->strAt(1) == "(") {
                 const auto range = functionNameMap.equal_range(tok->str());
 
-                // a visible variable with the same name hides the function templates
+                // A visible variable with the same name hides the function
+                // templates. A visible non template function with the same
+                // name might be a better match than the templates (overload
+                // resolution is not supported). Bail out in both cases.
                 ParsedType shadowingVariable;
-                if (range.first == range.second || ctx.symbols.lookupVariable(tok->str(), shadowingVariable))
+                if (range.first == range.second || ctx.symbols.lookupVariable(tok->str(), shadowingVariable) ||
+                    ctx.symbols.hasFunction(tok->str()))
                     continue;
 
                 // The name is looked up like the compiler does: in the

test/testsimplifytemplate.cpp

@@ -292,6 +292,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeduction11); // unqualified lookup: enclosing scopes, shadowing
         TEST_CASE(templateTypeDeduction12); // base class member templates, out of class method bodies
         TEST_CASE(templateTypeDeduction13); // members declared after the member function are visible
+        TEST_CASE(templateTypeDeduction14); // a non template overload might be a better match
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -6756,6 +6757,49 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeduction14() { // a non template overload might be a better match: don't deduce
+        {
+            // the non template f(int) wins the overload resolution (and the
+            // template would fail the substitution of int::type)
+            const char code[] = "template<class T>\n"
+                                "typename T::type f(T);\n"
+                                "int f(int);\n"
+                                "void use() { f(1); }";
+            const char exp[]  = "template < class T > "
+                                "T :: type f ( T ) ; "
+                                "int f ( int ) ; "
+                                "void use ( ) { f ( 1 ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // member function overload set
+            const char code[] = "struct M {\n"
+                                "    template<class T> void mf(T t) { (void)t; }\n"
+                                "    void mf(int);\n"
+                                "    void go() { mf(1); }\n"
+                                "};";
+            const char exp[]  = "struct M { "
+                                "template < class T > void mf ( T t ) { ( void ) t ; } "
+                                "void mf ( int ) ; "
+                                "void go ( ) { mf ( 1 ) ; } "
+                                "} ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // mixed overload set as a nested call: the return type is not
+            // known so the outer call is not deduced either
+            const char code[] = "template<class T> void g(T t) { (void)t; }\n"
+                                "template<class T> T h(T t) { return t; }\n"
+                                "long h(char);\n"
+                                "void use() { g(h('a')); }";
+            const char exp[]  = "template < class T > void g ( T t ) { ( void ) t ; } "
+                                "template < class T > T h ( T t ) { return t ; } "
+                                "long h ( char ) ; "
+                                "void use ( ) { g ( h ( 'a' ) ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
     void simplifyTemplateArgs1() {
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;"));
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;"));