Fix recursive deduction

Author: pfultz2

lib/templatesimplifier.cpp

@@ -2241,6 +2241,18 @@ bool TemplateSimplifier::alreadyHasNamespace(const TokenAndName &templateDeclara
     return Token::simpleMatch(tok->tokAt(offset), scope.c_str(), scope.size());
 }
 
+// Is the call at the name token a call of the function template with deduced template
+// arguments that type deduction can handle? deducibleParameterCount is the parameter
+// count of the template, -1 when deduction does not support it.
+static bool isDeducibleCall(const Token* nameTok, int deducibleParameterCount)
+{
+    if (deducibleParameterCount < 0 || nameTok->strAt(1) != "(")
+        return false;
+    std::vector<const Token*> args;
+    getFunctionArguments(nameTok, args);
+    return args.size() == static_cast<std::size_t>(deducibleParameterCount);
+}
+
 struct newInstantiation {
     newInstantiation(Token* t, std::string s) : token(t), scope(std::move(s)) {}
     Token* token;
@@ -2263,6 +2275,8 @@ void TemplateSimplifier::expandTemplate(
     const bool isFunction = templateDeclaration.isFunction();
     const bool isSpecialization = templateDeclaration.isSpecialization();
     const bool isVariable = templateDeclaration.isVariable();
+    // the parameter count of a function template whose calls type deduction can handle
+    const int deducibleParameterCount = isFunction ? DeductionCache().supportedParameterCount(templateDeclaration) : -1;
 
     // the incremental symbol database update only supports expansions that copy a
     // function template (see SymbolDatabase::addSymbolsForNewTokenRanges) - everything
@@ -2854,6 +2868,13 @@ void TemplateSimplifier::expandTemplate(
                     if (Token::Match(tok3->tokAt(-3), "> friend class|struct|union")) {
                         if (copy)
                             mTokenList.addtoken(tok3);
+                    } else if (copy && tok3 != templateDeclarationNameToken &&
+                               isDeducibleCall(tok3, deducibleParameterCount)) {
+                        // a recursive call with deduced template arguments: the arguments
+                        // may have other types than this instantiation, so the call is
+                        // left to type deduction - the declaration must stay until then
+                        mTokenList.addtoken(tok3);
+                        mPendingTypeDeductions = true;
                     } else if (copy) {
                         // add namespace if necessary
                         if (!templateDeclaration.scope().empty() &&
@@ -4512,8 +4533,10 @@ void TemplateSimplifier::simplifyTemplates(const std::time_t maxtime)
 
     mTokenizer.calculateScopes();
 
-    // all template names expanded during this call; merged into mExpandedTemplateNames
-    // when this call is done so later calls can reuse the expansions
+    // all template names expanded during this call - an instantiation is expanded only
+    // once even though the declaration may stay for later passes (deferred removal);
+    // merged into mExpandedTemplateNames when this call is done so later calls can
+    // reuse the expansions too
     std::set<std::string> expandedTemplateNamesThisCall;
 
     unsigned int passCount = 0;
@@ -4637,8 +4660,6 @@ void TemplateSimplifier::simplifyTemplates(const std::time_t maxtime)
             return false;
         });
 
-        std::set<std::string> expandedtemplates;
-
         for (auto iter1 = mTemplateDeclarations.crbegin(); iter1 != mTemplateDeclarations.crend(); ++iter1) {
             if (iter1->isAlias() || iter1->isFriend())
                 continue;
@@ -4657,15 +4678,13 @@ void TemplateSimplifier::simplifyTemplates(const std::time_t maxtime)
                 *iter1,
                 specializations,
                 maxtime,
-                expandedtemplates);
+                expandedTemplateNamesThisCall);
             if (instantiated) {
                 mInstantiatedTemplates.push_back(*iter1);
                 mTemplateNamePos.clear(); // positions might be invalid after instantiations
             }
         }
 
-        expandedTemplateNamesThisCall.insert(expandedtemplates.cbegin(), expandedtemplates.cend());
-
         for (auto it = mInstantiatedTemplates.cbegin(); it != mInstantiatedTemplates.cend(); ++it) {
             auto decl = std::find_if(mTemplateDeclarations.begin(), mTemplateDeclarations.end(), [&it](const TokenAndName& decl) {
                 return decl.token() == it->token();

test/testsimplifytemplate.cpp

@@ -318,6 +318,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeductionNested);      // calls inside a body created by deduction are deduced too
         TEST_CASE(templateTypeDeductionOutOfLine);   // member template defined out of line, class in a namespace
         TEST_CASE(templateTypeDeductionShadowedType); // the deduced type name means another type in the template's scope
+        TEST_CASE(templateTypeDeductionRecursion);   // recursive calls are deduced, not renamed to the current instantiation
         TEST_CASE(templateTypeDeductionEnum);        // enum arguments deduce the enum, not its underlying type
         TEST_CASE(templateTypeDeductionArray);       // array arguments: only the decayed dimension is a pointer
         TEST_CASE(templateTypeDeductionConstPointer); // "const T *": the parameter provides the pointee const
@@ -7507,6 +7508,60 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeductionRecursion()
+    { // a call of the template inside its own body must not be renamed to the
+      // instantiation being expanded - the argument types may differ
+        { // the recursive call instantiates another type
+            const char code[] = "template<class T> int f2(T t) { long l = 0; return f2(l); }\n"
+                                "int g(int i) { return f2(i); }";
+            const char exp[] = "int f2<int> ( int t ) ; "
+                               "int f2<long> ( long t ) ; "
+                               "int g ( int i ) { return f2<int> ( i ) ; } "
+                               "int f2<int> ( int t ) { long l ; l = 0 ; return f2<long> ( l ) ; } "
+                               "int f2<long> ( long t ) { long l ; l = 0 ; return f2<long> ( l ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+        { // explicit template arguments at the call site: same expansion
+            const char code[] = "template<class T> int f2(T t) { long l = 0; return f2(l); }\n"
+                                "int g(int i) { return f2<int>(i); }";
+            const char exp[] = "int f2<int> ( int t ) ; "
+                               "int f2<long> ( long t ) ; "
+                               "int g ( int i ) { return f2<int> ( i ) ; } "
+                               "int f2<int> ( int t ) { long l ; l = 0 ; return f2<long> ( l ) ; } "
+                               "int f2<long> ( long t ) { long l ; l = 0 ; return f2<long> ( l ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        { // a literal argument
+            const char code[] = "template<class T> int f(T t) { return f(\"x\"); }\n"
+                                "int g(int i) { return f(i); }";
+            const char exp[] = "int f<int> ( int t ) ; "
+                               "int f<constchar*> ( const char * t ) ; "
+                               "int g ( int i ) { return f<int> ( i ) ; } "
+                               "int f<int> ( int t ) { return f<constchar*> ( \"x\" ) ; } "
+                               "int f<constchar*> ( const char * t ) { return f<constchar*> ( \"x\" ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        { // the recursion uses the same type
+            const char code[] = "template<class T> int f(T t) { if (t) return f(t - 1); return 0; }\n"
+                                "int g(int i) { return f(i); }";
+            const char exp[] = "int f<int> ( int t ) ; "
+                               "int g ( int i ) { return f<int> ( i ) ; } "
+                               "int f<int> ( int t ) { if ( t ) { return f<int> ( t - 1 ) ; } return 0 ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+        { // a declaration that deduction does not handle (T&&): the recursive call is
+          // renamed to the instantiation as before, it would stay unresolved otherwise
+            const char code[] = "template<class T> int f(T&& t) { return f(1); }\n"
+                                "int g(int i) { return f<int>(i); }";
+            const char exp[] = "int f<int> ( int && t ) ; "
+                               "int g ( int i ) { return f<int> ( i ) ; } "
+                               "int f<int> ( int && t ) { return f<int> ( 1 ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
     void templateTypeDeductionEnum()
     {
         { // an enum variable has the ValueType of the underlying integer type - the enum