checkpoint

AST/ByteCode/libcxx/deref-to-array.cpp now compiles

But there are more tests getting regressed now, as I
have disabled ShouldPreserveTemplateArgumentsPacks,
which caused bugs for deref-to-array.cpp

Failed Tests (13):
  Clang :: AST/ByteCode/libcxx/minmax.cpp
  Clang :: AST/ByteCode/libcxx/primitive-temporary.cpp
  Clang :: CXX/drs/cwg25xx.cpp
  Clang :: CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp
  Clang :: CXX/temp/temp.constr/temp.constr.normal/p1.cpp
  Clang :: CXX/temp/temp.param/p10-2a.cpp
  Clang :: CodeGenCXX/mangle-concept.cpp
  Clang :: Modules/pr62943.cppm
  Clang :: SemaCXX/cxx2c-fold-exprs.cpp
  Clang :: SemaTemplate/concepts-recursive-inst.cpp
  Clang :: SemaTemplate/concepts.cpp
  Clang :: SemaTemplate/instantiate-template-argument.cpp
  Clang :: SemaTemplate/temp_arg_nontype_cxx2c.cpp

Author: zyn0217

clang/lib/Sema/SemaConcept.cpp

@@ -380,15 +380,23 @@ SubstitutionInTemplateArguments(
             Constraint.getParameterMapping(), MLTAL, SubstArgs) ||
         Trap.hasErrorOccurred())
       return std::nullopt;
+    // Sema::CheckTemplateArgumentInfo CTAI;
+    // auto *TD = const_cast<TemplateDecl *>(
+    //     cast<TemplateDecl>(Constraint.getConstraintDecl()));
+    // if (S.CheckTemplateArgumentList(TD, TD->getLocation(), SubstArgs,
+    //                                 /*DefaultArguments=*/{},
+    //                                 /*PartialTemplateArgs=*/true, CTAI))
+    //   return std::nullopt;
     NormalizedConstraint::OccurenceList Used =
         Constraint.mappingOccurenceList();
     SubstitutedOuterMost =
         llvm::to_vector_of<TemplateArgument>(MLTAL.getOutermost());
-    for (unsigned I = 0, MappedIndex = 0; I < SubstArgs.size(); I++)
-      if (I < Used.size() && Used[I]) {
+    for (unsigned I = 0, MappedIndex = 0; I < Used.size(); I++) {
+      TemplateArgument Arg;
+      if (Used[I])
         // SubstitutedOuterMost[I].dump();
         // SubstArgs[MappedIndex].getArgument().dump();
-        TemplateArgument Arg = S.Context.getCanonicalTemplateArgument(
+        Arg = S.Context.getCanonicalTemplateArgument(
               SubstArgs[MappedIndex++].getArgument());
         if (I < SubstitutedOuterMost.size())
           SubstitutedOuterMost[I] = Arg;
@@ -681,7 +689,7 @@ static bool calculateConstraintSatisfaction(
   Ok = calculateConstraintSatisfaction(S, Constraint.getRHS(), Template,
                                          TemplateNameLoc, MLTAL, Satisfaction,
                                          PackSubstitutionIndex);
-  if(Ok && Satisfaction.IsSatisfied && !Satisfaction.ContainsErrors)
+  if (Ok && Satisfaction.IsSatisfied && !Satisfaction.ContainsErrors)
     Satisfaction.Details.erase(Satisfaction.Details.begin() + EffectiveDetailEndIndex,
                                Satisfaction.Details.end());
   return Ok;
@@ -1590,7 +1598,7 @@ substituteParameterMappings(Sema &S, NormalizedConstraintWithParamMapping &N,
           /*OnlyDeduced=*/false,
           /*Depth=*/0, OccurringIndices);
     } else if (N.getKind() == NormalizedConstraint::ConstraintKind::ConceptId) {
-      auto Args = static_cast<ConceptIdConstraint &>(N)
+      auto *Args = static_cast<ConceptIdConstraint &>(N)
                       .getConceptId()
                       ->getTemplateArgsAsWritten();
       if (Args)
@@ -1629,12 +1637,25 @@ substituteParameterMappings(Sema &S, NormalizedConstraintWithParamMapping &N,
   if (S.SubstTemplateArgumentsInParameterMapping(N.getParameterMapping(), MLTAL,
                                                  SubstArgs))
     return true;
+  // Sema::CheckTemplateArgumentInfo CTAI;
+  // auto *TD =
+  //     const_cast<TemplateDecl *>(cast<TemplateDecl>(N.getConstraintDecl()));
+  // if (S.CheckTemplateArgumentList(TD, TD->getLocation(), SubstArgs,
+  //                                 /*DefaultArguments=*/{},
+  //                                 /*PartialTemplateArgs=*/true, CTAI))
+  //   return true;
   TemplateArgumentLoc *TempArgs =
       new (S.Context) TemplateArgumentLoc[SubstArgs.size()];
+  // for (unsigned I = 0; I < CTAI.SugaredConverted.size(); ++I)
+  //   TempArgs[I] = S.getTrivialTemplateArgumentLoc(CTAI.SugaredConverted[I],
+  //                                                 QualType(), SourceLocation());
   llvm::copy(SubstArgs.arguments(), TempArgs);
   N.updateParameterMapping(
       N.mappingOccurenceList(),
       MutableArrayRef<TemplateArgumentLoc>(TempArgs, SubstArgs.size()));
+  // N.updateParameterMapping(N.mappingOccurenceList(),
+  //                          MutableArrayRef<TemplateArgumentLoc>(
+  //                              TempArgs, CTAI.SugaredConverted.size()));
   return false;
 }
 
@@ -1643,13 +1664,11 @@ substituteParameterMappings(Sema &S, ConceptIdConstraint &N,
                             const MultiLevelTemplateArgumentList &MLTAL,
                             const ASTTemplateArgumentListInfo *ArgsAsWritten) {
 
-  {
     if (N.getConstraintDecl()) {
       substituteParameterMappings(
           S, static_cast<NormalizedConstraintWithParamMapping &>(N), MLTAL,
           ArgsAsWritten);
     }
-  }
   return substituteParameterMappings(S, N.getNormalizedConstraint(), MLTAL,
                                      ArgsAsWritten);
 }

clang/lib/Sema/SemaTemplate.cpp

@@ -5972,6 +5972,17 @@ bool Sema::CheckTemplateArgumentList(
         return true;
       }
 
+      // For constraint parameter mapping, we have already built a pack in
+      // TransformTemplateArguments
+      // if (inParameterMappingSubstitution()) {
+      //   llvm::copy(SugaredArgumentPack, std::back_inserter(CTAI.SugaredConverted));
+      //   SugaredArgumentPack.clear();
+      //   llvm::copy(CanonicalArgumentPack, std::back_inserter(CTAI.CanonicalConverted));
+      //   CanonicalArgumentPack.clear();
+      //   ++Param;
+      //   continue;
+      // }
+
       CTAI.SugaredConverted.push_back(
           TemplateArgument::CreatePackCopy(Context, SugaredArgumentPack));
       SugaredArgumentPack.clear();

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -7077,10 +7077,13 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
     break;
 
   case Type::UnaryTransform:
-    if (!OnlyDeduced)
-      MarkUsedTemplateParameters(Ctx,
-                                 cast<UnaryTransformType>(T)->getUnderlyingType(),
-                                 OnlyDeduced, Depth, Used);
+    if (!OnlyDeduced) {
+      auto *UTT = cast<UnaryTransformType>(T);
+      auto Next = UTT->getUnderlyingType();
+      if (Next.isNull())
+        Next = UTT->getBaseType();
+      MarkUsedTemplateParameters(Ctx, Next, OnlyDeduced, Depth, Used);
+    }
     break;
 
   case Type::PackExpansion:

clang/lib/Sema/SemaTemplateInstantiate.cpp

@@ -1526,7 +1526,10 @@ class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
     }
 
   bool ShouldPreserveTemplateArgumentsPacks() const {
-    return PreserveArgumentPacks;
+    // This is disabled temporarily.
+    // We need to figure out a way to correctly handle packs outside of
+    // CheckTemplateArguments
+    return false && PreserveArgumentPacks;
   }
 
     TemplateArgument
@@ -2212,8 +2215,7 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
     if (Arg.getKind() != TemplateArgument::Expression) {
       assert(SemaRef.inParameterMappingSubstitution());
       // FIXME: SourceLocation()?
-      ExprResult E = SemaRef.BuildExpressionFromNonTypeTemplateArgument(
-          Arg, SourceLocation());
+      ExprResult E = SemaRef.BuildExpressionFromNonTypeTemplateArgument(Arg, SourceLocation());
       if (E.isInvalid())
         return E;
       Arg = TemplateArgument(E.get(), /*IsCanonical=*/false);

clang/lib/Sema/TreeTransform.h

@@ -7005,11 +7005,11 @@ QualType TreeTransform<Derived>::TransformUnaryTransformType(
                                                             TypeLocBuilder &TLB,
                                                      UnaryTransformTypeLoc TL) {
   QualType Result = TL.getType();
+  TypeSourceInfo *NewBaseTSI = TL.getUnderlyingTInfo();
   if (Result->isDependentType()) {
     const UnaryTransformType *T = TL.getTypePtr();
 
-    TypeSourceInfo *NewBaseTSI =
-        getDerived().TransformType(TL.getUnderlyingTInfo());
+    NewBaseTSI = getDerived().TransformType(TL.getUnderlyingTInfo());
     if (!NewBaseTSI)
       return QualType();
     QualType NewBase = NewBaseTSI->getType();
@@ -7024,7 +7024,7 @@ QualType TreeTransform<Derived>::TransformUnaryTransformType(
   UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
   NewTL.setKWLoc(TL.getKWLoc());
   NewTL.setParensRange(TL.getParensRange());
-  NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
+  NewTL.setUnderlyingTInfo(NewBaseTSI);
   return Result;
 }