[clang] don't instantiate templates with injected arguments

[mizvekov]

Summary

There is a special situation with templates in local classes,
as can be seen in this example with generic lambdas in function scope:

template<class T1> void foo() {
    (void)[]<class T2>() {
      struct S {
        void bar() { (void)[]<class T3>(T2) {}; }
      };
    };
};
template void foo<int>();

As a consequence of the resolution of DR1484, bar is instantiated during the
substitution of foo, and in this context we would substitute the lambda within
it with it's own parameters "injected" (turned into arguments).

This can't be properly dealt with for at least a couple of reasons:

• The 'TemplateTypeParm' type itself can only deal with canonical replacement types, which the injected arguments are not.
• If T3 were constrained in the example above, our (non-conforming) eager substitution of type constraints would just leave that parameter dangling.

Instead of substituting with injected parameters, this patch just leaves those
inner levels unreplaced.

Since injected arguments appear to be unused within the users of
getTemplateInstantiationArgs, this patch just removes that support there and
leaves a couple of asserts in place.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[mizvekov]

.

[rsmith]

I think it's almost always true that we don't substitute into a template unless we've already substituted into all enclosing templates. The only exception I can think of is alias templates, which are substituted early, even in dependent contexts. So a case like:

template<typename T> struct A {
  template<typename U> using B = decltype([](auto){}(U()));
  void f(B<int>);
};
A<int> ai;

... might run into some problems here. But I would note we already crash on that testcase (and GCC miscompiles it, treating B<int> as int rather than void). So I suspect that's another whole can of worms.

clang/lib/Sema/SemaTemplateInstantiate.cpp

else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
         assert(Function->getPrimaryTemplate() && "No function template?");
         if (Function->getPrimaryTemplate()->isMemberSpecialization())
           break;
 
         // If this function is a generic lambda specialization, we are done.
         if (isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
           break;
 
-      } else if (FunctionTemplateDecl *FunTmpl
-                                   = Function->getDescribedFunctionTemplate()) {
-        // Add the "injected" template arguments.
-        Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
+      } else if (Function->getDescribedFunctionTemplate()) {
+        assert(Result.getNumSubstitutedLevels() == 0 &&
+               "Outer template not instantiated?");
       }
 
       // If this is a friend declaration and it declares an entity at
       // namespace scope, take arguments from its lexical parent
       // instead of its semantic parent, unless of course the pattern we're
       // instantiating actually comes from the file's context!
       if (Function->getFriendObjectKind() &&
           Function->getDeclContext()->isFileContext() &&
           (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
         Ctx = Function->getLexicalDeclContext();
         RelativeToPrimary = false;
         continue;
       }
     } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
       if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
-        QualType T = ClassTemplate->getInjectedClassNameSpecialization();
-        const TemplateSpecializationType *TST =
-            cast<TemplateSpecializationType>(Context.getCanonicalType(T));
-        Result.addOuterTemplateArguments(
-            llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
+        assert(Result.getNumSubstitutedLevels() == 0 &&
+               "Outer template not instantiated?");
         if (ClassTemplate->isMemberSpecialization())
           break;
       }
     }
 
     Ctx = Ctx->getParent();
     RelativeToPrimary = false;
   }

clang/test/SemaTemplate/generic-lambda.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+// expected-no-diagnostics
+
+template <class T, class U> constexpr bool is_same_v = false;
+template <class T> constexpr bool is_same_v<T, T> = true;
+template <class T, class U>
+concept is_same = is_same_v<T, U>;
+
+template <class T> struct X { using type = T; };
+template <class T, class U>
+concept C1 = is_same<T, X<U>>;
+
+template <class T1> X<X<X<T1>>> t1() {
+  return []<class T2>(T2) -> X<X<T2>> {
+    struct S {
+      static X<X<T2>> f() {
+        return []<class T3>(T3) -> X<T3> {
+          static_assert(is_same<T2, X<T1>>);
+          static_assert(is_same<T3, X<T2>>);
+          return X<T3>();
+        }(X<T2>());
+      }
+    };
+    return S::f();
+  }(X<T1>());
+};
+template X<X<X<int>>> t1<int>();
+
+#if 0 // FIXME: crashes
+template<class T1> auto t2() {
+  return []<class T2>(T2) {
+    struct S {
+      static auto f() {
+        return []<class T3>(T3) {
+          static_assert(is_same<T2, X<T1>>);
+          static_assert(is_same<T3, X<T2>>);
+          return X<T3>();
+        }(X<T2>());
+      }
+    };
+    return S::f();
+  }(X<T1>());
+};
+template auto t2<int>();
+static_assert(is_same<decltype(t2<int>()), X<X<X<int>>>>);
+
+template<class T1> C1<X<X<T1>>> auto t3() {
+  return []<C1<T1> T2>(T2) -> C1<X<T2>> auto {
+    struct S {
+      static auto f() {
+        return []<C1<T2> T3>(T3) -> C1<T3> auto {
+          return X<T3>();
+        }(X<T2>());
+      }
+    };
+    return S::f();
+  }(X<T1>());
+};
+template C1<X<X<int>>> auto t3<int>();
+static_assert(is_same<decltype(t3<int>()), X<X<X<int>>>>);
+#endif