[Concepts] Fix Concepts on generic lambda in a VarTemplateSpecDecl

[erichkeane]

Summary

As fallout of the Deferred Concept Instantiation patch (babdef27c5), we
got a number of reports of a regression, where we asserted when
instantiating a constraint on a generic lambda inside of a variable
template. See: https://github.com/llvm/llvm-project/issues/57958

The problem was that getTemplateInstantiationArgs function only walked
up declaration contexts, and missed that this is not necessarily the
case with a lambda (which can ALSO be in a separate context).

This patch refactors the getTemplateInstantiationArgs function in a way
that is hopefully more readable, and fixes the problem with the concepts
on a generic lambda.

[erichkeane]

clang/test/SemaTemplate/concepts-lambda.cpp

26

Huh... this f2 example seems to ICE for some reason, I could swear it worked, but building a different patch on top of this one showed me this fails.

Looking into it now, but it isn't critical to this patch, so if the rest looks good, I might remove this test case and fix it in a followup.

[erichkeane]

Looks like that problem was fixed easy enough, so back to all tests passing :)

[shafik]

I made mostly minor comments, the diff is difficult to follow wrt to what has really changed but it mostly makes sense. I will probably need a second look.

clang/lib/Sema/SemaConcept.cpp

507–511

584–587

1071–1074

clang/lib/Sema/SemaTemplate.cpp

6105–6108

clang/lib/Sema/SemaTemplateDeduction.cpp

2878–2881

clang/lib/Sema/SemaTemplateInstantiate.cpp

48

Maybe put both bool fields back to back.

255–258

This read a little awkward.

Maybe something more like "When collecting arguments ForContraintInstantion indicates that we should..."

264

Dead code?

271–291

Should we assert on ND?

300

This reads weird, my instant is that this should flip to the opposite value when this is true. Maybe an enum with names like RelativeToPrimayOff or something more explicit like that.

[erichkeane]

Did @shafik s suggestions. And yes, most of the work is just copy/pasted with slight changes to work in the new refactor, which does make it tougher to read, sorry about that :(

[tahonermann]

The refactoring looks like a good improvement to me. I think there may be some opportunities to make it more robust. I did some spot checking that previous behavior is retained, but didn't exhaustively do such checking; it does look like many of the changes were mechanical bus as Shafik noted, it is a bit difficult to review.

clang/lib/Sema/SemaConcept.cpp

510

This would previously have passed true for LookBeyondLambda and false for IncludeContainingStruct. The merge of both parameters to ForConstraintInstantiation makes that no longer possible. I don't know if that is a good thing or not. Perhaps this was a latent bug?

1067

This would previously have passed true for LookBeyondLambda and false for IncludeContainingStruct. The merge of both parameters to ForConstraintInstantiation makes that no longer possible. I don't know if that is a good thing or not. Perhaps this was a latent bug?

clang/lib/Sema/SemaTemplateDeduction.cpp

2881

This would previously have passed true for LookBeyondLambda and false for IncludeContainingStruct. The merge of both parameters to ForConstraintInstantiation makes that no longer possible. I don't know if that is a good thing or not. Perhaps this was a latent bug?

clang/lib/Sema/SemaTemplateInstantiate.cpp

48

Suggestion: rename RelativeToPrimaryOff to ClearRelativeToPrimary or SetRelativeToPrimaryFalse.

239

242–243

Tangent: When I was investigating this function a while back, I was uncertain what purpose Innermost serves and I didn't find the comment helpful. It appears that there is exactly one call to getTemplateInstantiationArgs() that passes a non-null value for it. That occurs in Sema::CheckTemplateArgumentList() and happens because a template is passed as ND and, while template arguments have been identified, a specialization has not yet been formed, so those arguments are passed for Innermost.

I suggest updating the comment:

/// \param Innermost if non-NULL, specifies a template argument list for the template
/// declaration passed as \p ND.

Perhaps it is worth adding an assert that, if Innermost is non-null, that ND corresponds to a template declaration (not a specialization).

251

296

302–305

This seems a little fragile. How about rolling the else case into the main if/else chain above so that R.NextDecl is always set? We could then assert on it. I added an illustrative suggested edit above. This would require changing a number of the handlers to set NextDecl where they currently don't, but being explicit about the decl navigation in those cases might make the flow easier to understand.

[erichkeane]

clang/lib/Sema/SemaConcept.cpp

510

Yeah, I think it was. At the time I put the 2 parameters in, I did a "only set it if I find a place that it NEEDS it". Thinking further through, I can't think of ANY reason these two needed to be different.

I ran this patch against all my workloads I have (like libcxx), and none changed behavior.

1067

Same answer as above.

clang/lib/Sema/SemaTemplateDeduction.cpp

2881

same :)

clang/lib/Sema/SemaTemplateInstantiate.cpp

255–258

Made another run at it.

302–305

Hrm... an interesting idea. I've got a patch that I'm cleaning up to do this that I think will end up handling this alright. The only awkward is the DontClearRelativeToPrimary function.

I CONSIDERED doing a 'builder' pattern for Response, but that doesn't try very hard to statically enforce what we're hoping for here. BUT, let me know what you think of what I have.

[erichkeane]

Do all the things Tom requested.

[JohelEGP]

I can confirm that, with this patch, Clang successfully compiles my actual code base.

[tahonermann]

I think this looks good. I took more time to compare with the current code and it looks to me like behavioral consistency is maintained where desired.

I added one comments requesting a change to a comment (to be made when committing the changes) and another comment with a question asked to improve my own understanding (that might also indicate that some additional comments would be helpful).

clang/lib/Sema/SemaTemplateInstantiate.cpp

75–77

I think the selected portion of this comment would be better placed inside the function before the call to isClassScopeExplicitSpecialization.

255–259

More a question than a review comment: why is ForConstraintInstantiation needed? The behavior it enables seems to me like the behavior that would always be desired. When would template arguments for such enclosing templates not be wanted?

[erichkeane]

clang/lib/Sema/SemaTemplateInstantiate.cpp

255–259

Apparently we DONT always want the full depth. It is the intent to only get as far back as 'needed' in some cases, and ForConstraintInstantiation causes us to go 'all the way to the TU' as far as I can tell. TBH, I'm not super clear on it. I tried at one point just modifying it, and it broke a ton of tests.

[tahonermann]

clang/lib/Sema/SemaTemplateInstantiate.cpp

255–259

Ok, thanks. My guess is that implies bugs elsewhere but that isn't a concern for this change!

clang/include/clang/AST/DeclBase.h

public:
   const TranslationUnitDecl *getTranslationUnitDecl() const {
     return const_cast<Decl*>(this)->getTranslationUnitDecl();
   }
 
   bool isInAnonymousNamespace() const;
 
   bool isInStdNamespace() const;
 
+  // Return true if this is a FileContext Decl.
+  bool isFileContextDecl() const;
+
   ASTContext &getASTContext() const LLVM_READONLY;
 
   /// Helper to get the language options from the ASTContext.
   /// Defined out of line to avoid depending on ASTContext.h.
   const LangOptions &getLangOpts() const LLVM_READONLY;
 
   void setAccess(AccessSpecifier AS) {
     Access = AS;

clang/include/clang/Sema/Sema.h

 
   //===--------------------------------------------------------------------===//
   // C++ Template Instantiation
   //
 
   MultiLevelTemplateArgumentList getTemplateInstantiationArgs(
       const NamedDecl *D, const TemplateArgumentList *Innermost = nullptr,
       bool RelativeToPrimary = false, const FunctionDecl *Pattern = nullptr,
-      bool LookBeyondLambda = false, bool IncludeContainingStruct = false);
+      bool ForConstraintInstantiation = false);
 
   /// A context in which code is being synthesized (where a source location
   /// alone is not sufficient to identify the context). This covers template
   /// instantiation and various forms of implicitly-generated functions.
   struct CodeSynthesisContext {
     /// The kind of template instantiation we are performing
     enum SynthesisKind {
       /// We are instantiating a template declaration. The entity is

clang/lib/AST/DeclBase.cpp

bool Decl::isInAnonymousNamespace() const {
   return false;
 }
 
 bool Decl::isInStdNamespace() const {
   const DeclContext *DC = getDeclContext();
   return DC && DC->isStdNamespace();
 }
 
+bool Decl::isFileContextDecl() const {
+  const auto *DC = dyn_cast<DeclContext>(this);
+  return DC && DC->isFileContext();
+}
+
 TranslationUnitDecl *Decl::getTranslationUnitDecl() {
   if (auto *TUD = dyn_cast<TranslationUnitDecl>(this))
     return TUD;
 
   DeclContext *DC = getDeclContext();
   assert(DC && "This decl is not contained in a translation unit!");
 
   while (!DC->isTranslationUnit()) {

clang/lib/Sema/SemaConcept.cpp

 llvm::Optional<MultiLevelTemplateArgumentList>
 Sema::SetupConstraintCheckingTemplateArgumentsAndScope(
     FunctionDecl *FD, llvm::Optional<ArrayRef<TemplateArgument>> TemplateArgs,
     LocalInstantiationScope &Scope) {
   MultiLevelTemplateArgumentList MLTAL;
 
   // Collect the list of template arguments relative to the 'primary' template.
   // We need the entire list, since the constraint is completely uninstantiated
   // at this point.
-  MLTAL = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary*/ true,
-                                       /*Pattern*/ nullptr,
-                                       /*LookBeyondLambda*/ true);
+  MLTAL = getTemplateInstantiationArgs(FD, /*Innermost=*/nullptr,
+                                       /*RelativeToPrimary=*/true,
+                                       /*Pattern=*/nullptr,
+                                       /*ForConstraintInstantiation=*/true);
   if (SetupConstraintScope(FD, TemplateArgs, MLTAL, Scope))
     return {};
 
   return MLTAL;
 }
 
 bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
                                     ConstraintSatisfaction &Satisfaction,

 }
 
 
 // Figure out the to-translation-unit depth for this function declaration for
 // the purpose of seeing if they differ by constraints. This isn't the same as
 // getTemplateDepth, because it includes already instantiated parents.
 static unsigned CalculateTemplateDepthForConstraints(Sema &S,
                                                      const NamedDecl *ND) {
   MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
-      ND, nullptr, /*RelativeToPrimary*/ true,
-      /*Pattern*/ nullptr,
-      /*LookBeyondLambda*/ true, /*IncludeContainingStruct*/ true);
+      ND, /*Innermost=*/nullptr, /*RelativeToPrimary=*/true,
+      /*Pattern=*/nullptr,
+      /*ForConstraintInstantiation=*/true);
   return MLTAL.getNumSubstitutedLevels();
 }
 
 namespace {
   class AdjustConstraintDepth : public TreeTransform<AdjustConstraintDepth> {
   unsigned TemplateDepth = 0;
   public:
   using inherited = TreeTransform<AdjustConstraintDepth>;
bool Sema::CheckInstantiatedFunctionTemplateConstraints(
 
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = Method->getParent();
   }
   CXXThisScopeRAII ThisScope(*this, Record, ThisQuals, Record != nullptr);
+  FunctionScopeRAII FuncScope(*this);
+  if (isLambdaCallOperator(Decl))
+    PushLambdaScope();
+  else
+    FuncScope.disable();
+
   llvm::SmallVector<Expr *, 1> Converted;
   return CheckConstraintSatisfaction(Template, TemplateAC, Converted, *MLTAL,
                                      PointOfInstantiation, Satisfaction);
 }
 
 static void diagnoseUnsatisfiedRequirement(Sema &S,
                                            concepts::ExprRequirement *Req,
                                            bool First) {
substituteParameterMappings(Sema &S, NormalizedConstraint &N,
   return false;
 }
 
 static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
                                         const ConceptSpecializationExpr *CSE) {
   TemplateArgumentList TAL{TemplateArgumentList::OnStack,
                            CSE->getTemplateArguments()};
   MultiLevelTemplateArgumentList MLTAL =
       S.getTemplateInstantiationArgs(CSE->getNamedConcept(), &TAL,
-                                     /*RelativeToPrimary*/ true,
-                                     /*Pattern*/ nullptr,
-                                     /*LookBeyondLambda*/ true);
+                                     /*RelativeToPrimary=*/true,
+                                     /*Pattern=*/nullptr,
+                                     /*ForConstraintInstantiation=*/true);
 
   return substituteParameterMappings(S, N, CSE->getNamedConcept(), MLTAL,
                                      CSE->getTemplateArgsAsWritten());
 }
 
 Optional<NormalizedConstraint>
 NormalizedConstraint::fromConstraintExprs(Sema &S, NamedDecl *D,
                                           ArrayRef<const Expr *> E) {

clang/lib/Sema/SemaTemplate.cpp

if (!PartialTemplateArgs) {
     Qualifiers ThisQuals;
     if (const auto *Method =
             dyn_cast_or_null<CXXMethodDecl>(Template->getTemplatedDecl()))
       ThisQuals = Method->getMethodQualifiers();
 
     ContextRAII Context(*this, NewContext);
     CXXThisScopeRAII(*this, RD, ThisQuals, RD != nullptr);
 
     MultiLevelTemplateArgumentList MLTAL = getTemplateInstantiationArgs(
-        Template, &StackTemplateArgs, /*RelativeToPrimary*/ true,
-        /*Pattern*/ nullptr,
-        /*LookBeyondLambda*/ true, /*IncludeContainingStruct*/ true);
+        Template, &StackTemplateArgs, /*RelativeToPrimary=*/true,
+        /*Pattern=*/nullptr,
+        /*ForConceptInstantiation=*/true);
     if (EnsureTemplateArgumentListConstraints(
             Template, MLTAL,
             SourceRange(TemplateLoc, TemplateArgs.getRAngleLoc()))) {
       if (ConstraintsNotSatisfied)
         *ConstraintsNotSatisfied = true;
       return true;
     }
   }

clang/lib/Sema/SemaTemplateDeduction.cpp

CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
                                 TemplateDeductionInfo& Info) {
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   Template->getAssociatedConstraints(AssociatedConstraints);
   MultiLevelTemplateArgumentList MLTAL;
 
   bool NeedsReplacement = DeducedArgsNeedReplacement(Template);
   TemplateArgumentList DeducedTAL{TemplateArgumentList::OnStack, DeducedArgs};
 
   MLTAL = S.getTemplateInstantiationArgs(
-      Template, /*InnerMost*/ NeedsReplacement ? nullptr : &DeducedTAL,
-      /*RelativeToPrimary*/ true, /*Pattern*/
-      nullptr, /*LookBeyondLambda*/ true);
+      Template, /*InnerMost=*/NeedsReplacement ? nullptr : &DeducedTAL,
+      /*RelativeToPrimary=*/true, /*Pattern=*/
+      nullptr, /*ForConstraintInstantiation=*/true);
 
   // getTemplateInstantiationArgs picks up the non-deduced version of the
   // template args when this is a variable template partial specialization and
   // not class-scope explicit specialization, so replace with Deduced Args
   // instead of adding to inner-most.
   if (NeedsReplacement)
     MLTAL.replaceInnermostTemplateArguments(DeducedArgs);
 

clang/lib/Sema/SemaTemplateInstantiate.cpp

 
 using namespace clang;
 using namespace sema;
 
 //===----------------------------------------------------------------------===/
 // Template Instantiation Support
 //===----------------------------------------------------------------------===/
 
-/// Retrieve the template argument list(s) that should be used to
-/// instantiate the definition of the given declaration.
-///
-/// \param D the declaration for which we are computing template instantiation
-/// arguments.
-///
-/// \param Innermost if non-NULL, the innermost template argument list.
-///
-/// \param RelativeToPrimary true if we should get the template
-/// arguments relative to the primary template, even when we're
-/// dealing with a specialization. This is only relevant for function
-/// template specializations.
-///
-/// \param Pattern If non-NULL, indicates the pattern from which we will be
-/// instantiating the definition of the given declaration, \p D. This is
-/// used to determine the proper set of template instantiation arguments for
-/// friend function template specializations.
-///
-/// \param LookBeyondLambda Indicates that this collection of arguments should
-/// continue looking when it encounters a lambda generic call operator.
-///
-/// \param IncludeContainingStructArgs Indicates that this collection of
-/// arguments should include arguments for any class template that this
-/// declaration is included inside of.
-
-MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
-    const NamedDecl *D, const TemplateArgumentList *Innermost,
-    bool RelativeToPrimary, const FunctionDecl *Pattern, bool LookBeyondLambda,
-    bool IncludeContainingStructArgs) {
-  // Accumulate the set of template argument lists in this structure.
-  MultiLevelTemplateArgumentList Result;
-
-  if (Innermost)
-    Result.addOuterTemplateArguments(Innermost);
-
-  const auto *Ctx = dyn_cast<DeclContext>(D);
-  if (!Ctx) {
-    Ctx = D->getDeclContext();
-
-    // Add template arguments from a variable template instantiation. For a
-    // class-scope explicit specialization, there are no template arguments
-    // at this level, but there may be enclosing template arguments.
-    const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(D);
-    if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
-      // We're done when we hit an explicit specialization.
-      if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
-          !isa<VarTemplatePartialSpecializationDecl>(Spec))
-        return Result;
+namespace {
+namespace TemplateInstArgsHelpers {
+struct Response {
+  const Decl *NextDecl = nullptr;
+  bool IsDone = false;
+  bool ClearRelativeToPrimary = true;
+  static Response Done() {
+    Response R;
+    R.IsDone = true;
+    return R;
+  }
+  static Response ChangeDecl(const Decl *ND) {
+    Response R;
+    R.NextDecl = ND;
+    return R;
+  }
+  static Response ChangeDecl(const DeclContext *Ctx) {
+    Response R;
+    R.NextDecl = Decl::castFromDeclContext(Ctx);
+    return R;
+  }
+
+  static Response UseNextDecl(const Decl *CurDecl) {
+    return ChangeDecl(CurDecl->getDeclContext());
+  }
+
+  static Response DontClearRelativeToPrimaryNextDecl(const Decl *CurDecl) {
+    Response R = Response::UseNextDecl(CurDecl);
+    R.ClearRelativeToPrimary = false;
+    return R;
+  }
+};
+// Add template arguments from a variable template instantiation.
+Response
+HandleVarTemplateSpec(const VarTemplateSpecializationDecl *VarTemplSpec,
+                      MultiLevelTemplateArgumentList &Result) {
+  // For a class-scope explicit specialization, there are no template arguments
+  if (VarTemplSpec->isClassScopeExplicitSpecialization())
+    return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
+
+  if (VarTemplSpec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+      !isa<VarTemplatePartialSpecializationDecl>(VarTemplSpec))
+    return Response::Done();
 
-      Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
+  Result.addOuterTemplateArguments(
+      &VarTemplSpec->getTemplateInstantiationArgs());
 
-      // If this variable template specialization was instantiated from a
-      // specialized member that is a variable template, we're done.
-      assert(Spec->getSpecializedTemplate() && "No variable template?");
-      llvm::PointerUnion<VarTemplateDecl*,
-                         VarTemplatePartialSpecializationDecl*> Specialized
-                             = Spec->getSpecializedTemplateOrPartial();
-      if (VarTemplatePartialSpecializationDecl *Partial =
-              Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
-        if (Partial->isMemberSpecialization())
-          return Result;
-      } else {
-        VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
-        if (Tmpl->isMemberSpecialization())
-          return Result;
-      }
-    }
+  assert(VarTemplSpec->getSpecializedTemplate() && "No variable template?");
+  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
+      Specialized = VarTemplSpec->getSpecializedTemplateOrPartial();
+      return Response::Done();
+      return Response::Done();
+  return Response::DontClearRelativeToPrimaryNextDecl(VarTemplSpec);
 
-    // If we have a template template parameter with translation unit context,
-    // then we're performing substitution into a default template argument of
-    // this template template parameter before we've constructed the template
-    // that will own this template template parameter. In this case, we
-    // use empty template parameter lists for all of the outer templates
-    // to avoid performing any substitutions.
-    if (Ctx->isTranslationUnit()) {
-      if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
-        for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
-          Result.addOuterTemplateArguments(None);
-        return Result;
-      }
-    }
-  }
+Response
+HandleDefaultTempArgIntoTempTempParam(const TemplateTemplateParmDecl *TTP,
+                                      MultiLevelTemplateArgumentList &Result) {
+  return Response::Done();
 
-  while (!Ctx->isFileContext()) {
-    // Add template arguments from a class template instantiation.
-    const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
-    if (Spec && !Spec->isClassScopeExplicitSpecialization()) {
-      // We're done when we hit an explicit specialization.
-      if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
-          !isa<ClassTemplatePartialSpecializationDecl>(Spec))
-        break;
+Response
+HandleClassTemplateSpec(const ClassTemplateSpecializationDecl *ClassTemplSpec,
+                        MultiLevelTemplateArgumentList &Result) {
+  if (!ClassTemplSpec->isClassScopeExplicitSpecialization()) {
+    if (ClassTemplSpec->getSpecializationKind() == TSK_ExplicitSpecialization &&
+        !isa<ClassTemplatePartialSpecializationDecl>(ClassTemplSpec))
+      return Response::Done();
 
-      Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
+    Result.addOuterTemplateArguments(
+        &ClassTemplSpec->getTemplateInstantiationArgs());
 
-      // If this class template specialization was instantiated from a
-      // specialized member that is a class template, we're done.
-      assert(Spec->getSpecializedTemplate() && "No class template?");
-      if (Spec->getSpecializedTemplate()->isMemberSpecialization())
-        break;
-    }
-    // Add template arguments from a function template specialization.
-    else if (const auto *Function = dyn_cast<FunctionDecl>(Ctx)) {
-      if (!RelativeToPrimary &&
-          Function->getTemplateSpecializationKindForInstantiation() ==
-              TSK_ExplicitSpecialization)
-        break;
+    assert(ClassTemplSpec->getSpecializedTemplate() && "No class template?");
+    if (ClassTemplSpec->getSpecializedTemplate()->isMemberSpecialization())
+      return Response::Done();
+  return Response::UseNextDecl(ClassTemplSpec);
+}
+
+Response HandleFunction(const FunctionDecl *Function,
+                        MultiLevelTemplateArgumentList &Result,
+                        const FunctionDecl *Pattern, bool RelativeToPrimary,
+                        bool ForConstraintInstantiation) {
+    return Response::Done();
 
-      if (!RelativeToPrimary && Function->getTemplateSpecializationKind() ==
-                                    TSK_ExplicitSpecialization) {
-        // This is an implicit instantiation of an explicit specialization. We
-        // don't get any template arguments from this function but might get
-        // some from an enclosing template.
-      } else if (const TemplateArgumentList *TemplateArgs
-            = Function->getTemplateSpecializationArgs()) {
-        // Add the template arguments for this specialization.
-        Result.addOuterTemplateArguments(TemplateArgs);
+  if (!RelativeToPrimary &&
+      Function->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
+    return Response::UseNextDecl(Function);
+  } else if (const TemplateArgumentList *TemplateArgs =
+                 Function->getTemplateSpecializationArgs()) {
 
-        // If this function was instantiated from a specialized member that is
-        // a function template, we're done.
-        assert(Function->getPrimaryTemplate() && "No function template?");
-        if (Function->getPrimaryTemplate()->isMemberSpecialization())
-          break;
+      return Response::Done();
 
-        // If this function is a generic lambda specialization, we are done.
-        if (!LookBeyondLambda &&
-            isGenericLambdaCallOperatorOrStaticInvokerSpecialization(Function))
-          break;
+    if (!ForConstraintInstantiation &&
+      return Response::Done();
 
-      } else if (Function->getDescribedFunctionTemplate()) {
-        assert((IncludeContainingStructArgs ||
-                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->getNonTransparentDeclContext()->isFileContext() &&
-          (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
-        Ctx = Function->getLexicalDeclContext();
-        RelativeToPrimary = false;
-        continue;
-      }
-    } else if (const auto *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
-      if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
-        assert((IncludeContainingStructArgs ||
-                Result.getNumSubstitutedLevels() == 0) &&
-               "Outer template not instantiated?");
-        if (ClassTemplate->isMemberSpecialization())
-          break;
-        if (IncludeContainingStructArgs) {
-          QualType RecordType = Context.getTypeDeclType(Rec);
-          QualType Injected = cast<InjectedClassNameType>(RecordType)
-                                  ->getInjectedSpecializationType();
-          const auto *InjectedType = cast<TemplateSpecializationType>(Injected);
-          Result.addOuterTemplateArguments(InjectedType->template_arguments());
-        }
-      }
-      bool IsFriend = Rec->getFriendObjectKind() ||
-                      (Rec->getDescribedClassTemplate() &&
-                       Rec->getDescribedClassTemplate()->getFriendObjectKind());
-      if (IncludeContainingStructArgs && IsFriend &&
-          Rec->getNonTransparentDeclContext()->isFileContext() &&
-          (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
-        Ctx = Rec->getLexicalDeclContext();
-        RelativeToPrimary = false;
-        continue;
-      }
-    }
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+    return Response::ChangeDecl(Function->getLexicalDeclContext());
+  }
+  return Response::UseNextDecl(Function);
+
+Response HandleRecordDecl(const CXXRecordDecl *Rec,
+                          MultiLevelTemplateArgumentList &Result,
+                          ASTContext &Context,
+                          bool ForConstraintInstantiation) {
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+      return Response::Done();
+    if (ForConstraintInstantiation) {
+
+  if (ForConstraintInstantiation && IsFriend &&
+      Rec->getNonTransparentDeclContext()->isFileContext()) {
+    return Response::ChangeDecl(Rec->getLexicalDeclContext());
+
+  // This is to make sure we pick up the VarTemplateSpecializationDecl that this
+  // lambda is defined inside of.
+  if (Rec->isLambda())
+    if (const Decl *LCD = Rec->getLambdaContextDecl())
+      return Response::ChangeDecl(LCD);
+
+  return Response::UseNextDecl(Rec);
 
-    Ctx = Ctx->getParent();
+Response HandleGenericDeclContext(const Decl *CurDecl) {
+  return Response::UseNextDecl(CurDecl);
+}
+} // namespace TemplateInstArgsHelpers
+} // namespace
+
+/// Retrieve the template argument list(s) that should be used to
+/// instantiate the definition of the given declaration.
+///
+/// \param ND the declaration for which we are computing template instantiation
+/// arguments.
+///
+/// \param Innermost if non-NULL, specifies a template argument list for the
+/// template declaration passed as ND.
+///
+/// \param RelativeToPrimary true if we should get the template
+/// arguments relative to the primary template, even when we're
+/// dealing with a specialization. This is only relevant for function
+/// template specializations.
+///
+/// \param Pattern If non-NULL, indicates the pattern from which we will be
+/// instantiating the definition of the given declaration, \p ND. This is
+/// used to determine the proper set of template instantiation arguments for
+/// friend function template specializations.
+///
+/// \param ForConstraintInstantiation when collecting arguments,
+/// ForConstraintInstantiation indicates we should continue looking when
+/// encountering a lambda generic call operator, and continue looking for
+/// arguments on an enclosing class template.
+
+MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
+    const NamedDecl *ND, const TemplateArgumentList *Innermost,
+    bool RelativeToPrimary, const FunctionDecl *Pattern,
+    bool ForConstraintInstantiation) {
+  assert(ND && "Can't find arguments for a decl if one isn't provided");
+  // Accumulate the set of template argument lists in this structure.
+  MultiLevelTemplateArgumentList Result;
+
+  if (Innermost)
+    Result.addOuterTemplateArguments(Innermost);
+
+  const Decl *CurDecl = ND;
+
+  while (!CurDecl->isFileContextDecl()) {
+    using namespace TemplateInstArgsHelpers;
+    Response R;
+    if (const auto *VarTemplSpec =
+            dyn_cast<VarTemplateSpecializationDecl>(CurDecl)) {
+      R = HandleVarTemplateSpec(VarTemplSpec, Result);
+    } else if (const auto *ClassTemplSpec =
+                   dyn_cast<ClassTemplateSpecializationDecl>(CurDecl)) {
+      R = HandleClassTemplateSpec(ClassTemplSpec, Result);
+    } else if (const auto *Function = dyn_cast<FunctionDecl>(CurDecl)) {
+      R = HandleFunction(Function, Result, Pattern, RelativeToPrimary,
+                         ForConstraintInstantiation);
+    } else if (const auto *Rec = dyn_cast<CXXRecordDecl>(CurDecl)) {
+      R = HandleRecordDecl(Rec, Result, Context, ForConstraintInstantiation);
+    } else if (!isa<DeclContext>(CurDecl)) {
+      R = Response::DontClearRelativeToPrimaryNextDecl(CurDecl);
+      if (CurDecl->getDeclContext()->isTranslationUnit()) {
+        if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(CurDecl)) {
+          R = HandleDefaultTempArgIntoTempTempParam(TTP, Result);
+        }
+      }
+    } else {
+      R = HandleGenericDeclContext(CurDecl);
+    }
+
+    if (R.IsDone)
+      return Result;
+    if (R.ClearRelativeToPrimary)
       RelativeToPrimary = false;
+    assert(R.NextDecl);
+    CurDecl = R.NextDecl;
   }
 
   return Result;
 }
 
 bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   switch (Kind) {
   case TemplateInstantiation:
   case ExceptionSpecInstantiation:
   case DefaultTemplateArgumentInstantiation:

clang/test/SemaTemplate/concepts-lambda.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s
 // expected-no-diagnostics
 
 namespace GH57945 {
   template<typename T>
     concept c = true;
 
   template<typename>
     auto f = []() requires c<void> {
     };
 
   void g() {
       f<int>();
   };
 }
+
+namespace GH57945_2 {
+  template<typename>
+    concept c = true;
+
+  template<typename T>
+    auto f = [](auto... args) requires c<T>  {
+    };
+
+  template <typename T>
+  auto f2 = [](auto... args)
+    requires (sizeof...(args) > 0)
+  {};
+
+  void g() {
+      f<void>();
+      f2<void>(5.0);
+  }
+}
+
+namespace GH57958 {
+  template<class> concept C = true;
+  template<int> constexpr bool v = [](C auto) { return true; }(0);
+  int _ = v<0>;
+}
+namespace GH57958_2 {
+  template<class> concept C = true;
+  template<int> constexpr bool v = [](C auto...) { return true; }(0);
+  int _ = v<0>;
+}
+
+namespace GH57971 {
+  template<typename>
+    concept any = true;
+
+  template<typename>
+    auto f = [](any auto) {
+    };
+
+  using function_ptr = void(*)(int);
+  function_ptr ptr = f<void>;
+}