Fix pack expansion

clang/test/SemaTemplate/alias-template-with-lambdas.cpp

Author: zyn0217

clang/include/clang/Sema/SemaConcept.h

@@ -65,7 +65,7 @@ struct NormalizedConstraint {
   struct AtomicBits {
     LLVM_PREFERRED_TYPE(ConstraintKind)
     unsigned Kind : 5;
-    unsigned : 1;
+    unsigned Placeholder : 1;
     unsigned PackSubstitutionIndex : 26;
     llvm::SmallBitVector Indexes;
     TemplateArgumentLoc *Args;
@@ -114,6 +114,7 @@ struct NormalizedConstraint {
                        const NamedDecl *ConstraintDecl,
                        UnsignedOrNone PackIndex)
       : Atomic{llvm::to_underlying(ConstraintKind::Atomic),
+               /*Placeholder=*/0,
                PackIndex.toInternalRepresentation(),
                /*Indexes=*/{},
                /*Args=*/nullptr,
@@ -134,7 +135,8 @@ struct NormalizedConstraint {
                        NormalizedConstraint *SubConstraint,
                        UnsignedOrNone PackIndex)
       : ConceptId{{llvm::to_underlying(ConstraintKind::ConceptId),
-                   PackIndex.toInternalRepresentation(), /*Indexes=*/{},
+                   /*Placeholder=*/0, PackIndex.toInternalRepresentation(),
+                   /*Indexes=*/{},
                    /*Args=*/nullptr, ConceptId, ConstraintDecl},
                   SubConstraint} {}
 
@@ -237,7 +239,8 @@ struct NormalizedConstraint {
   fromAssociatedConstraints(Sema &S, const NamedDecl *D,
                             ArrayRef<AssociatedConstraint> ACs);
   static NormalizedConstraint *fromConstraintExpr(Sema &S, const NamedDecl *D,
-                                                  const Expr *E);
+                                                  const Expr *E,
+                                                  UnsignedOrNone SubstIndex);
 };
 
 class CompoundConstraint : public NormalizedConstraint {

clang/lib/Sema/SemaConcept.cpp

@@ -368,6 +368,8 @@ SubstitutionInTemplateArguments(
 
   TemplateArgumentListInfo SubstArgs;
   if (Constraint.hasParameterMapping()) {
+    Sema::ArgPackSubstIndexRAII SubstIndex(
+        S, Constraint.getPackSubstitutionIndex());
     if (S.SubstTemplateArgumentsInParameterMapping(
             Constraint.getParameterMapping(), MLTAL, SubstArgs) ||
         Trap.hasErrorOccurred())
@@ -590,6 +592,8 @@ static bool calculateConstraintSatisfaction(
       return Ok;
 
     Sema::SFINAETrap Trap(S);
+    Sema::ArgPackSubstIndexRAII SubstIndex(
+        S, Constraint.getPackSubstitutionIndex());
 
     const ASTTemplateArgumentListInfo *Ori =
         Constraint.getConceptId()->getTemplateArgsAsWritten();
@@ -604,7 +608,8 @@ static bool calculateConstraintSatisfaction(
                                           Ori->NumTemplateArgs, TransArgs))
       return Ok;
 
-    if (S.SubstTemplateArguments(TransArgs.arguments(), MLTAL, OutArgs) ||
+    if (S.SubstTemplateArguments(TransArgs.arguments(), *SubstitutedArgs,
+                                 OutArgs) ||
         Trap.hasErrorOccurred())
       return Ok;
 
@@ -1669,11 +1674,13 @@ static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
 NormalizedConstraint *NormalizedConstraint::fromAssociatedConstraints(
     Sema &S, const NamedDecl *D, ArrayRef<AssociatedConstraint> ACs) {
   assert(ACs.size() != 0);
-  auto Conjunction = fromConstraintExpr(S, D, ACs[0].ConstraintExpr);
+  auto *Conjunction =
+      fromConstraintExpr(S, D, ACs[0].ConstraintExpr, ACs[0].ArgPackSubstIndex);
   if (!Conjunction)
     return nullptr;
   for (unsigned I = 1; I < ACs.size(); ++I) {
-    auto Next = fromConstraintExpr(S, D, ACs[I].ConstraintExpr);
+    auto *Next = fromConstraintExpr(S, D, ACs[I].ConstraintExpr,
+                                    ACs[I].ArgPackSubstIndex);
     if (!Next)
       return nullptr;
     Conjunction = CompoundConstraint::CreateConjunction(S.getASTContext(),
@@ -1682,9 +1689,8 @@ NormalizedConstraint *NormalizedConstraint::fromAssociatedConstraints(
   return Conjunction;
 }
 
-NormalizedConstraint *
-NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
-                                         const Expr *E) {
+NormalizedConstraint *NormalizedConstraint::fromConstraintExpr(
+    Sema &S, const NamedDecl *D, const Expr *E, UnsignedOrNone SubstIndex) {
   assert(E != nullptr);
 
   // C++ [temp.constr.normal]p1.1
@@ -1705,10 +1711,10 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
   // See http://cplusplus.github.io/concepts-ts/ts-active.html#28
 
   if (LogicalBinOp BO = E) {
-    auto LHS = fromConstraintExpr(S, D, BO.getLHS());
+    auto *LHS = fromConstraintExpr(S, D, BO.getLHS(), SubstIndex);
     if (!LHS)
       return nullptr;
-    auto RHS = fromConstraintExpr(S, D, BO.getRHS());
+    auto *RHS = fromConstraintExpr(S, D, BO.getRHS(), SubstIndex);
     if (!RHS)
       return nullptr;
 
@@ -1736,7 +1742,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
       ConceptDecl *CD = CSE->getNamedConcept();
       SubNF = NormalizedConstraint::fromAssociatedConstraints(
           S, CSE->getNamedConcept(),
-          AssociatedConstraint(CD->getConstraintExpr()));
+          AssociatedConstraint(CD->getConstraintExpr(), SubstIndex));
 
       if (!SubNF)
         return nullptr;
@@ -1746,7 +1752,7 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
 
     return ConceptIdConstraint::Create(S.getASTContext(),
                                        CSE->getConceptReference(), SubNF, D,
-                                       S.ArgPackSubstIndex);
+                                       SubstIndex);
 
   } else if (auto *FE = dyn_cast<const CXXFoldExpr>(E);
              FE && S.getLangOpts().CPlusPlus26 &&
@@ -1761,8 +1767,8 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
             : FoldExpandedConstraint::FoldOperatorKind::Or;
 
     if (FE->getInit()) {
-      auto LHS = fromConstraintExpr(S, D, FE->getLHS());
-      auto RHS = fromConstraintExpr(S, D, FE->getRHS());
+      auto *LHS = fromConstraintExpr(S, D, FE->getLHS(), SubstIndex);
+      auto *RHS = fromConstraintExpr(S, D, FE->getRHS(), SubstIndex);
       if (!LHS || !RHS)
         return nullptr;
 
@@ -1779,13 +1785,13 @@ NormalizedConstraint::fromConstraintExpr(Sema &S, const NamedDecl *D,
                                                             : CCK_Disjunction),
           RHS);
     }
-    auto Sub = fromConstraintExpr(S, D, FE->getPattern());
+    auto *Sub = fromConstraintExpr(S, D, FE->getPattern(), SubstIndex);
     if (!Sub)
       return nullptr;
     return FoldExpandedConstraint::Create(S.getASTContext(), FE->getPattern(),
                                           Kind, Sub);
   }
-  return AtomicConstraint::Create(S.getASTContext(), E, D, S.ArgPackSubstIndex);
+  return AtomicConstraint::Create(S.getASTContext(), E, D, SubstIndex);
 }
 
 bool FoldExpandedConstraint::AreCompatibleForSubsumption(