Handle nested type deductions

Author: pfultz2

lib/templatesimplifier.cpp

@@ -1293,20 +1293,20 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
     if (tok->function() && !tok->function()->templateDef)
         return qualification;
 
-    if (!mUseTypeInformation) {
-        // Can the deduction succeed later, when type information is available? Scope
-        // matching is not possible yet - the declaration may be in a base class - so
-        // consider all declarations with this name.
+    // Without type information for this call the deduction can not be done now: either
+    // the type information pass has not run yet, or the call is in a function body that
+    // an instantiation created during this pass - the symbol database does not know the
+    // new tokens yet. Can the deduction succeed later, when type information is
+    // available? Scope matching is not possible yet - the declaration may be in a base
+    // class - so consider all declarations with this name.
+    if (!mUseTypeInformation || !tok->scope()) {
         if (std::any_of(range.first, range.second, [&](const std::pair<const std::string, const TokenAndName*>& entry) {
             return deductionCache->supportedParameterCount(*entry.second) == instantiationArgs.size();
         }))
             mPendingTypeDeductions = true;
         return qualification;
     }
 
-    if (!tok->scope())
-        return qualification;
-
     // the scopes where the call name is looked up - see CallLookupLevels
     CallLookupLevels lookup;
     if (!qualification.empty())

test/testsimplifytemplate.cpp

@@ -315,6 +315,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeductionRedeclared);  // twice declared template: the surviving declaration stays valid
         TEST_CASE(templateTypeDeductionFullRebuild); // --template-full-rebuild gives the same result
         TEST_CASE(templateTypeDeductionMultiPass);   // a pending deduction survives later simplifier passes
+        TEST_CASE(templateTypeDeductionNested);      // calls inside a body created by deduction are deduced too
         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
@@ -7275,6 +7276,54 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS("", errout_str());
     }
 
+    void templateTypeDeductionNested()
+    { // a call inside a function body that a deduction instantiated has no symbol
+      // database scope yet when it is seen - the deduction must be retried in the next
+      // round instead of being given up
+        {
+            const char code[] = "template<class T> T twice(T t) { return t * 2; }\n"
+                                "template<class T> T thrice(T t) { return twice(t) + t; }\n"
+                                "int g(int a) { return thrice(a); }";
+            const char exp[] = "int twice<int> ( int t ) ; "
+                               "int thrice<int> ( int t ) ; "
+                               "int g ( int a ) { return thrice<int> ( a ) ; } "
+                               "int thrice<int> ( int t ) { return twice<int> ( t ) + t ; } "
+                               "int twice<int> ( int t ) { return t * 2 ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+            ASSERT_EQUALS("", errout_str());
+        }
+        { // three levels, each one needs another round
+            const char code[] = "template<class T> T a(T t) { return t; }\n"
+                                "template<class T> T b(T t) { return a(t); }\n"
+                                "template<class T> T c(T t) { return b(t); }\n"
+                                "long g(long x) { return c(x); }";
+            const char exp[] = "long a<long> ( long t ) ; "
+                               "long b<long> ( long t ) ; "
+                               "long c<long> ( long t ) ; "
+                               "long g ( long x ) { return c<long> ( x ) ; } "
+                               "long c<long> ( long t ) { return b<long> ( t ) ; } "
+                               "long b<long> ( long t ) { return a<long> ( t ) ; } "
+                               "long a<long> ( long t ) { return t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+            ASSERT_EQUALS("", errout_str());
+        }
+        { // the nested call uses a different type than the outer one
+            const char code[] = "template<class T> void sink(T t) { (void)t; }\n"
+                                "template<class T> void outer(T t) { sink(&t); }\n"
+                                "void g(int x) { outer(x); }";
+            const char exp[] = "void sink<int*> ( int * t ) ; "
+                               "void outer<int> ( int t ) ; "
+                               "void g ( int x ) { outer<int> ( x ) ; } "
+                               "void outer<int> ( int t ) { sink<int*> ( & t ) ; } "
+                               "void sink<int*> ( int * t ) { ( void ) t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
     void templateTypeDeductionEnum()
     {
         { // an enum variable has the ValueType of the underlying integer type - the enum