Handle global function template called from a class scope

Author: Your Name

lib/templatesimplifier.cpp

@@ -1906,22 +1906,37 @@ void TemplateSimplifier::deduceFunctionTemplateArguments()
                 tok = tok->tokAt(2);
             }
             if (tok->strAt(1) == "(") {
-                std::string fullName;
-                if (!qualification.empty())
-                    fullName = qualification + " :: " + tok->str();
-                else if (!scopeName.empty())
-                    fullName = scopeName + " :: " + tok->str();
-                else
-                    fullName = tok->str();
+                const auto range = functionNameMap.equal_range(tok->str());
+
+                // a visible variable with the same name hides the function templates
+                ParsedType shadowingVariable;
+                if (range.first == range.second || ctx.symbols.lookupVariable(tok->str(), shadowingVariable))
+                    continue;
 
-                // get all declarations with this name
+                // The name is looked up like the compiler does: in the
+                // enclosing scopes from the innermost outwards, where a match
+                // in an inner scope shadows declarations in outer scopes.
                 std::vector<const DeductionCandidate *> candidates;
-                const auto range = functionNameMap.equal_range(tok->str());
-                for (auto pos = range.first; pos != range.second; ++pos) {
-                    // look for declaration with same qualification or constructor with same qualification
-                    if (pos->second.declaration->fullName() == fullName ||
-                        (pos->second.declaration->scope() == fullName && tok->str() == pos->second.declaration->name()))
-                        candidates.push_back(&pos->second);
+                std::string scopePath = scopeName;
+                for (;;) {
+                    std::string fullName;
+                    if (!scopePath.empty())
+                        fullName = scopePath + " :: ";
+                    if (!qualification.empty())
+                        fullName += qualification + " :: ";
+                    fullName += tok->str();
+
+                    for (auto pos = range.first; pos != range.second; ++pos) {
+                        // look for declaration with same qualification or constructor with same qualification
+                        if (pos->second.declaration->fullName() == fullName ||
+                            (pos->second.declaration->scope() == fullName && tok->str() == pos->second.declaration->name()))
+                            candidates.push_back(&pos->second);
+                    }
+                    if (!candidates.empty() || scopePath.empty())
+                        break;
+                    // no match: retry in the next outer scope
+                    const std::string::size_type separator = scopePath.rfind(" :: ");
+                    scopePath = (separator == std::string::npos) ? "" : scopePath.substr(0, separator);
                 }
 
                 if (!candidates.empty())

test/testsimplifytemplate.cpp

@@ -289,6 +289,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeduction8); // deduction from expressions
         TEST_CASE(templateTypeDeduction9); // multiple parameters, scopes, bailouts
         TEST_CASE(templateTypeDeduction10); // parameter visibility: init list, const method
+        TEST_CASE(templateTypeDeduction11); // unqualified lookup: enclosing scopes, shadowing
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -6536,6 +6537,76 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void templateTypeDeduction11() { // unqualified lookup: enclosing scopes, shadowing
+        {
+            // global function template called from a class scope
+            const char code[] = "template<typename T> void f(T n) { (void)n; }\n"
+                                "struct A {\n"
+                                "    int m;\n"
+                                "    A(long n) : m(0) { f(n); }\n"
+                                "    void g(float v) const { f(v); }\n"
+                                "};";
+            const char exp[]  = "void f<long> ( long n ) ; "
+                                "void f<float> ( float n ) ; "
+                                "struct A { "
+                                "int m ; "
+                                "A ( long n ) : m ( 0 ) { f<long> ( n ) ; } "
+                                "void g ( float v ) const { f<float> ( v ) ; } "
+                                "} ; "
+                                "void f<long> ( long n ) { ( void ) n ; } "
+                                "void f<float> ( float n ) { ( void ) n ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // global function template called from a class nested in a namespace
+            const char code[] = "template<typename T> T twice(T v) { return v + v; }\n"
+                                "namespace N {\n"
+                                "    struct Inner {\n"
+                                "        long go(int a) { return twice(a); }\n"
+                                "    };\n"
+                                "}";
+            const char exp[]  = "int twice<int> ( int v ) ; "
+                                "namespace N { "
+                                "struct Inner { "
+                                "long go ( int a ) { return twice<int> ( a ) ; } "
+                                "} ; "
+                                "} "
+                                "int twice<int> ( int v ) { return v + v ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // a variable with the same name hides the function template
+            const char code[] = "template<typename T> void call(T v) { (void)v; }\n"
+                                "struct Functor { void operator()(int) const {} };\n"
+                                "void g() {\n"
+                                "    Functor call;\n"
+                                "    call(5);\n"
+                                "}";
+            const char exp[]  = "template < typename T > void call ( T v ) { ( void ) v ; } "
+                                "struct Functor { void operator() ( int ) const { } } ; "
+                                "void g ( ) { "
+                                "Functor call ; "
+                                "call . operator() ( 5 ) ; "
+                                "}";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // a member function template shadows a global function template
+            const char code[] = "template<typename T> void dup(T t) { (void)t; }\n"
+                                "struct B {\n"
+                                "    template<typename T> void dup(T t) { (void)t; }\n"
+                                "    void m() { dup(1L); }\n"
+                                "};";
+            const char exp[]  = "template < typename T > void dup ( T t ) { ( void ) t ; } "
+                                "struct B { "
+                                "void dup<long> ( long t ) ; "
+                                "void m ( ) { dup<long> ( 1L ) ; } "
+                                "} ; "
+                                "void B :: dup<long> ( long t ) { ( void ) t ; }";
+            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 >;"));