[clang] [Clang][Sema] Refactor collection of multi-level template argument lists (PR #106585)

via cfe-commits cfe-commits at lists.llvm.org
Thu Aug 29 09:58:26 PDT 2024


github-actions[bot] wrote:

<!--LLVM CODE FORMAT COMMENT: {clang-format}-->


:warning: C/C++ code formatter, clang-format found issues in your code. :warning:

<details>
<summary>
You can test this locally with the following command:
</summary>

``````````bash
git-clang-format --diff 6f62757e779492b288a98c7c2e27eba95a551e3b 7bbecfeae5bc40c3ead47cc4bf677eb705928812 --extensions h,cpp -- clang/test/CXX/temp/temp.constr/temp.constr.decl/p4.cpp clang/include/clang/AST/DeclTemplate.h clang/include/clang/Sema/Sema.h clang/lib/AST/DeclTemplate.cpp clang/lib/Sema/SemaConcept.cpp clang/lib/Sema/SemaDecl.cpp clang/lib/Sema/SemaDeclCXX.cpp clang/lib/Sema/SemaTemplate.cpp clang/lib/Sema/SemaTemplateDeduction.cpp clang/lib/Sema/SemaTemplateDeductionGuide.cpp clang/lib/Sema/SemaTemplateInstantiate.cpp clang/lib/Sema/SemaTemplateInstantiateDecl.cpp clang/lib/Serialization/ASTReader.cpp clang/lib/Serialization/ASTReaderDecl.cpp clang/lib/Serialization/ASTWriterDecl.cpp clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp
``````````

</details>

<details>
<summary>
View the diff from clang-format here.
</summary>

``````````diff
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index 6e6e075ac9..0e1f1f8b48 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -809,7 +809,8 @@ protected:
   };
 
   /// Pointer to the common data shared by all declarations of this
-  /// template, and a flag indicating if the template is a member specialization.
+  /// template, and a flag indicating if the template is a member
+  /// specialization.
   mutable llvm::PointerIntPair<CommonBase *, 1, bool> Common;
 
   /// Retrieves the "common" pointer shared by all (re-)declarations of
@@ -857,9 +858,7 @@ public:
   /// template<> template<typename T>
   /// struct X<int>::Inner { /* ... */ };
   /// \endcode
-  bool isMemberSpecialization() const {
-    return Common.getInt();
-  }
+  bool isMemberSpecialization() const { return Common.getInt(); }
 
   /// Note that this member template is a specialization.
   void setMemberSpecialization() {
@@ -2190,9 +2189,7 @@ public:
   }
 
   /// Note that this member template is a specialization.
-  void setMemberSpecialization() {
-    return InstantiatedFromMember.setInt(true);
-  }
+  void setMemberSpecialization() { return InstantiatedFromMember.setInt(true); }
 
   /// Retrieves the injected specialization type for this partial
   /// specialization.  This is not the same as the type-decl-type for
@@ -2947,9 +2944,7 @@ public:
   }
 
   /// Note that this member template is a specialization.
-  void setMemberSpecialization() {
-    return InstantiatedFromMember.setInt(true);
-  }
+  void setMemberSpecialization() { return InstantiatedFromMember.setInt(true); }
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index ac817135dc..78b2ba206e 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11384,7 +11384,8 @@ public:
       CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
       const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
       AccessSpecifier AS, SourceLocation ModulePrivateLoc,
-      SourceLocation FriendLoc, ArrayRef<TemplateParameterList *> OuterTemplateParamLists,
+      SourceLocation FriendLoc,
+      ArrayRef<TemplateParameterList *> OuterTemplateParamLists,
       bool IsMemberSpecialization, SkipBodyInfo *SkipBody = nullptr);
 
   /// Translates template arguments as provided by the parser
@@ -11424,7 +11425,8 @@ public:
   DeclResult ActOnVarTemplateSpecialization(
       Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous,
       SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
-      StorageClass SC, bool IsPartialSpecialization, bool IsMemberSpecialization);
+      StorageClass SC, bool IsPartialSpecialization,
+      bool IsMemberSpecialization);
 
   /// Get the specialization of the given variable template corresponding to
   /// the specified argument list, or a null-but-valid result if the arguments
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index 1815325eee..f5020cd385 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -586,7 +586,7 @@ static bool CheckConstraintSatisfaction(
   ArrayRef<TemplateArgument> TemplateArgs =
       TemplateArgsLists.getNumSubstitutedLevels() > 0
           ? TemplateArgsLists.getInnermost()
-          : ArrayRef<TemplateArgument> {};
+          : ArrayRef<TemplateArgument>{};
   Sema::InstantiatingTemplate Inst(S, TemplateIDRange.getBegin(),
       Sema::InstantiatingTemplate::ConstraintsCheck{},
       const_cast<NamedDecl *>(Template), TemplateArgs, TemplateIDRange);
@@ -908,8 +908,8 @@ bool Sema::CheckFunctionConstraints(const FunctionDecl *FD,
 // 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) {
+static unsigned CalculateTemplateDepthForConstraints(Sema &S,
+                                                     const NamedDecl *ND) {
   MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
       ND, ND->getLexicalDeclContext(), /*Final=*/false,
       /*Innermost=*/std::nullopt,
@@ -1061,11 +1061,11 @@ bool Sema::FriendConstraintsDependOnEnclosingTemplate(const FunctionDecl *FD) {
   SmallVector<const Expr *, 3> ACs;
   FTD->getAssociatedConstraints(ACs);
 
-  #if 0
+#if 0
   unsigned OldTemplateDepth = CalculateTemplateDepthForConstraints(*this, FD);
-  #else
+#else
   unsigned OldTemplateDepth = FTD->getTemplateParameters()->getDepth();
-  #endif
+#endif
   for (const Expr *Constraint : ACs)
     if (ConstraintExpressionDependsOnEnclosingTemplate(FD, OldTemplateDepth,
                                                        Constraint))
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 1844c19f01..4dc15a4a75 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -4501,10 +4501,10 @@ void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
   adjustDeclContextForDeclaratorDecl(New, Old);
 
   // Ensure the template parameters are compatible.
-  if (NewTemplate &&
-      !TemplateParameterListsAreEqual(NewTemplate, NewTemplate->getTemplateParameters(),
-                                      OldTemplate, OldTemplate->getTemplateParameters(),
-                                      /*Complain=*/true, TPL_TemplateMatch))
+  if (NewTemplate && !TemplateParameterListsAreEqual(
+                         NewTemplate, NewTemplate->getTemplateParameters(),
+                         OldTemplate, OldTemplate->getTemplateParameters(),
+                         /*Complain=*/true, TPL_TemplateMatch))
     return New->setInvalidDecl();
 
   // C++ [class.mem]p1:
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index e5e030cf52..bb9a69907c 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -17410,7 +17410,8 @@ DeclResult Sema::ActOnTemplatedFriendTag(
       return CheckClassTemplate(S, TagSpec, TagUseKind::Friend, TagLoc, SS,
                                 Name, NameLoc, Attr, TemplateParams, AS_public,
                                 /*ModulePrivateLoc=*/SourceLocation(),
-                                FriendLoc, TempParamLists.drop_back(), IsMemberSpecialization)
+                                FriendLoc, TempParamLists.drop_back(),
+                                IsMemberSpecialization)
           .get();
     } else {
       // The "template<>" header is extraneous.
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 16e3788d7d..79cf52cb09 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -1793,7 +1793,8 @@ DeclResult Sema::CheckClassTemplate(
     CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
     const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
     AccessSpecifier AS, SourceLocation ModulePrivateLoc,
-    SourceLocation FriendLoc, ArrayRef<TemplateParameterList *> OuterTemplateParamLists,
+    SourceLocation FriendLoc,
+    ArrayRef<TemplateParameterList *> OuterTemplateParamLists,
     bool IsMemberSpecialization, SkipBodyInfo *SkipBody) {
   assert(TemplateParams && TemplateParams->size() > 0 &&
          "No template parameters");
@@ -2037,8 +2038,7 @@ DeclResult Sema::CheckClassTemplate(
                           /*DelayTypeCreation=*/true);
   SetNestedNameSpecifier(*this, NewClass, SS);
   if (!OuterTemplateParamLists.empty())
-    NewClass->setTemplateParameterListsInfo(
-        Context, OuterTemplateParamLists);
+    NewClass->setTemplateParameterListsInfo(Context, OuterTemplateParamLists);
 
   // Add alignment attributes if necessary; these attributes are checked when
   // the ASTContext lays out the structure.
@@ -2081,26 +2081,28 @@ DeclResult Sema::CheckClassTemplate(
   // Ensure that the template parameter lists are compatible. Skip this check
   // for a friend in a dependent context: the template parameter list itself
   // could be dependent.
-  if (ShouldAddRedecl && PrevClassTemplate && !TemplateParameterListsAreEqual(
-      NewTemplate, TemplateParams,
-      PrevClassTemplate, PrevClassTemplate->getTemplateParameters(),
-      /*Complain=*/true, TPL_TemplateMatch))
+  if (ShouldAddRedecl && PrevClassTemplate &&
+      !TemplateParameterListsAreEqual(
+          NewTemplate, TemplateParams, PrevClassTemplate,
+          PrevClassTemplate->getTemplateParameters(),
+          /*Complain=*/true, TPL_TemplateMatch))
     return true;
 
   // Check the template parameter list of this declaration, possibly
   // merging in the template parameter list from the previous class
   // template declaration. Skip this check for a friend in a dependent
   // context, because the template parameter list might be dependent.
-  if (ShouldAddRedecl && CheckTemplateParameterList(
-      TemplateParams,
-      PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
-                        : nullptr,
-      (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
-       SemanticContext->isDependentContext())
-          ? TPC_ClassTemplateMember
-      : TUK == TagUseKind::Friend ? TPC_FriendClassTemplate
-                                  : TPC_ClassTemplate,
-      SkipBody))
+  if (ShouldAddRedecl &&
+      CheckTemplateParameterList(
+          TemplateParams,
+          PrevClassTemplate ? PrevClassTemplate->getTemplateParameters()
+                            : nullptr,
+          (SS.isSet() && SemanticContext && SemanticContext->isRecord() &&
+           SemanticContext->isDependentContext())
+              ? TPC_ClassTemplateMember
+          : TUK == TagUseKind::Friend ? TPC_FriendClassTemplate
+                                      : TPC_ClassTemplate,
+          SkipBody))
     Invalid = true;
 
   if (TUK == TagUseKind::Definition && (!SkipBody || !SkipBody->ShouldSkip))
@@ -3940,7 +3942,8 @@ void Sema::CheckDeductionGuideTemplate(FunctionTemplateDecl *TD) {
 DeclResult Sema::ActOnVarTemplateSpecialization(
     Scope *S, Declarator &D, TypeSourceInfo *DI, LookupResult &Previous,
     SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
-    StorageClass SC, bool IsPartialSpecialization, bool IsMemberSpecialization) {
+    StorageClass SC, bool IsPartialSpecialization,
+    bool IsMemberSpecialization) {
   // D must be variable template id.
   assert(D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId &&
          "Variable template specialization is declared with a template id.");
@@ -8261,15 +8264,12 @@ DeclResult Sema::ActOnClassTemplateSpecialization(
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
           << /*class template*/ 0 << (TUK == TagUseKind::Definition)
           << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
-      return CheckClassTemplate(S, TagSpec, TUK, KWLoc, SS,
-                                ClassTemplate->getIdentifier(),
-                                TemplateNameLoc,
-                                Attr,
-                                TemplateParams,
-                                AS_none, /*ModulePrivateLoc=*/SourceLocation(),
-                                /*FriendLoc*/SourceLocation(),
-                                TemplateParameterLists.drop_back(),
-                                isMemberSpecialization);
+      return CheckClassTemplate(
+          S, TagSpec, TUK, KWLoc, SS, ClassTemplate->getIdentifier(),
+          TemplateNameLoc, Attr, TemplateParams, AS_none,
+          /*ModulePrivateLoc=*/SourceLocation(),
+          /*FriendLoc*/ SourceLocation(), TemplateParameterLists.drop_back(),
+          isMemberSpecialization);
     }
 
     // Create a new class template partial specialization declaration node.
diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
index 7415e1e153..10ca5d6664 100644
--- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
+++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp
@@ -317,7 +317,8 @@ struct ConvertConstructorToDeductionGuideTransform {
     }
 
     if (NestedPattern)
-      OuterInstantiationArgs = SemaRef.getTemplateInstantiationArgs(/*D=*/nullptr, Template->getDeclContext());
+      OuterInstantiationArgs = SemaRef.getTemplateInstantiationArgs(
+          /*D=*/nullptr, Template->getDeclContext());
   }
 
   Sema &SemaRef;
@@ -786,8 +787,7 @@ buildAssociatedConstraints(Sema &SemaRef, FunctionTemplateDecl *F,
                                      getDepthAndIndex(TP).first + AdjustDepth);
       FirstUndeducedParamIdx += 1;
       assert(InnerArgsForBuildingRC[Index].isNull());
-      InnerArgsForBuildingRC[Index] =
-          Context.getInjectedTemplateArg(NewParam);
+      InnerArgsForBuildingRC[Index] = Context.getInjectedTemplateArg(NewParam);
       continue;
     }
     TemplateArgumentLoc Input =
@@ -828,11 +828,12 @@ buildAssociatedConstraints(Sema &SemaRef, FunctionTemplateDecl *F,
   // NOTE: The underlying deduction guide F is instantiated -- either from an
   // explicitly-written deduction guide member, or from a constructor.
   MultiLevelTemplateArgumentList ArgsForBuildingRC =
-      SemaRef.getTemplateInstantiationArgs(
-        F, F->getLexicalDeclContext(),
-        /*Final=*/false, /*Innermost=*/InnerArgsForBuildingRC,
-        /*RelativeToPrimary=*/true,
-        /*ForConstraintInstantiation=*/true);;
+      SemaRef.getTemplateInstantiationArgs(F, F->getLexicalDeclContext(),
+                                           /*Final=*/false,
+                                           /*Innermost=*/InnerArgsForBuildingRC,
+                                           /*RelativeToPrimary=*/true,
+                                           /*ForConstraintInstantiation=*/true);
+  ;
   ArgsForBuildingRC.setKind(clang::TemplateSubstitutionKind::Rewrite);
 
   ExprResult E = SemaRef.SubstExpr(RC, ArgsForBuildingRC);
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 74698a783f..9541f07bfb 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -140,7 +140,7 @@ bool isLambdaEnclosedByTypeAliasDecl(
 }
 
 struct TemplateInstantiationArgumentCollecter
-    : DeclVisitor<TemplateInstantiationArgumentCollecter, Decl*> {
+    : DeclVisitor<TemplateInstantiationArgumentCollecter, Decl *> {
   Sema &S;
   MultiLevelTemplateArgumentList &Result;
   std::optional<ArrayRef<TemplateArgument>> Innermost;
@@ -148,18 +148,14 @@ struct TemplateInstantiationArgumentCollecter
   bool ForConstraintInstantiation;
 
   TemplateInstantiationArgumentCollecter(
-      Sema &S,
-      MultiLevelTemplateArgumentList &Result,
+      Sema &S, MultiLevelTemplateArgumentList &Result,
       std::optional<ArrayRef<TemplateArgument>> Innermost,
-      bool RelativeToPrimary,
-      bool ForConstraintInstantiation) :
-          S(S), Result(Result), Innermost(Innermost), RelativeToPrimary(RelativeToPrimary),
-          ForConstraintInstantiation(ForConstraintInstantiation) {
-  }
+      bool RelativeToPrimary, bool ForConstraintInstantiation)
+      : S(S), Result(Result), Innermost(Innermost),
+        RelativeToPrimary(RelativeToPrimary),
+        ForConstraintInstantiation(ForConstraintInstantiation) {}
 
-  Decl *Done() {
-    return nullptr;
-  }
+  Decl *Done() { return nullptr; }
 
   Decl *ChangeDecl(const Decl *D) {
     RelativeToPrimary = false;
@@ -170,23 +166,22 @@ struct TemplateInstantiationArgumentCollecter
     return ChangeDecl(Decl::castFromDeclContext(DC));
   }
 
-  Decl *UseNextDecl(const Decl *D) {
-    return ChangeDecl(D->getDeclContext());
-  }
+  Decl *UseNextDecl(const Decl *D) { return ChangeDecl(D->getDeclContext()); }
 
-  Decl *DontClearRelativeToPrimaryNextDecl(const Decl* D) {
-    return const_cast<Decl *>(
-        Decl::castFromDeclContext(D->getDeclContext()));
+  Decl *DontClearRelativeToPrimaryNextDecl(const Decl *D) {
+    return const_cast<Decl *>(Decl::castFromDeclContext(D->getDeclContext()));
   }
 
   void AddInnermostTemplateArguments(const Decl *D) {
     assert(Innermost);
-    Result.addOuterTemplateArguments(const_cast<Decl*>(D), *Innermost, /*Final=*/false);
+    Result.addOuterTemplateArguments(const_cast<Decl *>(D), *Innermost,
+                                     /*Final=*/false);
     Innermost.reset();
   }
 
-  void AddOuterTemplateArguments(const Decl *D, ArrayRef<TemplateArgument> Args, bool Final) {
-    Result.addOuterTemplateArguments(const_cast<Decl*>(D), Args, Final);
+  void AddOuterTemplateArguments(const Decl *D, ArrayRef<TemplateArgument> Args,
+                                 bool Final) {
+    Result.addOuterTemplateArguments(const_cast<Decl *>(D), Args, Final);
   }
 
   Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTPD) {
@@ -202,14 +197,15 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *FTD) {
-    assert((ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
-          "outer template not instantiated?");
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+        "outer template not instantiated?");
 
     if (Innermost)
       AddInnermostTemplateArguments(FTD);
     else if (ForConstraintInstantiation)
-      AddOuterTemplateArguments(
-          FTD, FTD->getInjectedTemplateArgs(), /*Final=*/false);
+      AddOuterTemplateArguments(FTD, FTD->getInjectedTemplateArgs(),
+                                /*Final=*/false);
 
     if (FTD->isMemberSpecialization())
       return Done();
@@ -220,14 +216,15 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitVarTemplateDecl(VarTemplateDecl *VTD) {
-    assert((ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
-          "outer template not instantiated?");
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+        "outer template not instantiated?");
 
     if (Innermost)
       AddInnermostTemplateArguments(VTD);
     else if (ForConstraintInstantiation)
-      AddOuterTemplateArguments(
-          VTD, VTD->getInjectedTemplateArgs(), /*Final=*/false);
+      AddOuterTemplateArguments(VTD, VTD->getInjectedTemplateArgs(),
+                                /*Final=*/false);
 
     if (VTD->isMemberSpecialization())
       return Done();
@@ -236,14 +233,15 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitClassTemplateDecl(ClassTemplateDecl *CTD) {
-    assert((ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
-          "outer template not instantiated?");
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+        "outer template not instantiated?");
 
     if (Innermost)
       AddInnermostTemplateArguments(CTD);
     else if (ForConstraintInstantiation)
-      AddOuterTemplateArguments(
-          CTD, CTD->getInjectedTemplateArgs(), /*Final=*/false);
+      AddOuterTemplateArguments(CTD, CTD->getInjectedTemplateArgs(),
+                                /*Final=*/false);
 
     if (CTD->isMemberSpecialization())
       return Done();
@@ -254,20 +252,22 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *TATD) {
-    assert((ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
-          "outer template not instantiated?");
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+        "outer template not instantiated?");
     if (Innermost)
       AddInnermostTemplateArguments(TATD);
     else if (ForConstraintInstantiation)
-      AddOuterTemplateArguments(
-          TATD, TATD->getInjectedTemplateArgs(), /*Final=*/false);
+      AddOuterTemplateArguments(TATD, TATD->getInjectedTemplateArgs(),
+                                /*Final=*/false);
 
     return UseNextDecl(TATD);
   }
 
   Decl *VisitConceptDecl(ConceptDecl *CD) {
-    assert((ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
-          "outer template not instantiated?");
+    assert(
+        (ForConstraintInstantiation || Result.getNumSubstitutedLevels() == 0) &&
+        "outer template not instantiated?");
     if (Innermost)
       AddInnermostTemplateArguments(CD);
 
@@ -275,12 +275,15 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitFunctionDecl(FunctionDecl *FD) {
-    assert(!FD->getDescribedFunctionTemplate() && "not for templated declarations");
+    assert(!FD->getDescribedFunctionTemplate() &&
+           "not for templated declarations");
 
     if (!RelativeToPrimary) {
       // Add template arguments from a function template specialization.
-      if (const MemberSpecializationInfo *MSI = FD->getMemberSpecializationInfo();
-          MSI && MSI->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
+      if (const MemberSpecializationInfo *MSI =
+              FD->getMemberSpecializationInfo();
+          MSI &&
+          MSI->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
         return Done();
 
       // This is an implicit instantiation of an explicit specialization. We
@@ -291,16 +294,16 @@ struct TemplateInstantiationArgumentCollecter
     }
 
     if (const TemplateArgumentList *TemplateArgs =
-                   FD->getTemplateSpecializationArgs()) {
+            FD->getTemplateSpecializationArgs()) {
       // Add the template arguments for this specialization.
       if (Innermost)
         AddInnermostTemplateArguments(FD);
       else
-        AddOuterTemplateArguments(
-            FD, TemplateArgs->asArray(), /*Final=*/false);
+        AddOuterTemplateArguments(FD, TemplateArgs->asArray(), /*Final=*/false);
 
       if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization ||
-          (FD->getFriendObjectKind() && !FD->getPrimaryTemplate()->getFriendObjectKind()))
+          (FD->getFriendObjectKind() &&
+           !FD->getPrimaryTemplate()->getFriendObjectKind()))
         return UseNextDecl(FD);
 
       // If this function was instantiated from a specialized member that is
@@ -330,10 +333,12 @@ struct TemplateInstantiationArgumentCollecter
   }
 
   Decl *VisitCXXRecordDecl(CXXRecordDecl *RD) {
-    assert(!RD->getDescribedClassTemplate() && "not for templated declarations");
+    assert(!RD->getDescribedClassTemplate() &&
+           "not for templated declarations");
 
     if (const MemberSpecializationInfo *MSI = RD->getMemberSpecializationInfo();
-        MSI && MSI->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
+        MSI &&
+        MSI->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
       return Done();
 
     if (ForConstraintInstantiation && RD->getFriendObjectKind() &&
@@ -352,7 +357,7 @@ struct TemplateInstantiationArgumentCollecter
       if (auto TypeAlias = getEnclosingTypeAliasTemplateDecl(S);
           ForConstraintInstantiation && TypeAlias) {
         if (isLambdaEnclosedByTypeAliasDecl(RD->getLambdaCallOperator(),
-                                          TypeAlias.PrimaryTypeAliasDecl)) {
+                                            TypeAlias.PrimaryTypeAliasDecl)) {
           AddOuterTemplateArguments(TypeAlias.Template,
                                     TypeAlias.AssociatedTemplateArguments,
                                     /*Final=*/false);
@@ -377,9 +382,10 @@ struct TemplateInstantiationArgumentCollecter
     return UseNextDecl(RD);
   }
 
-  Decl *VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *CTSD) {
-    // For a class-scope explicit specialization, there are no template arguments
-    // at this level, but there may be enclosing template arguments.
+  Decl *
+  VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *CTSD) {
+    // For a class-scope explicit specialization, there are no template
+    // arguments at this level, but there may be enclosing template arguments.
     if (CTSD->isClassScopeExplicitSpecialization() &&
         !isa<ClassTemplatePartialSpecializationDecl>(CTSD))
       return DontClearRelativeToPrimaryNextDecl(CTSD);
@@ -390,11 +396,11 @@ struct TemplateInstantiationArgumentCollecter
       return Done();
 
     if (Innermost)
-        AddInnermostTemplateArguments(CTSD);
+      AddInnermostTemplateArguments(CTSD);
     else
-      AddOuterTemplateArguments(
-          CTSD, CTSD->getTemplateInstantiationArgs().asArray(),
-          /*Final=*/false);
+      AddOuterTemplateArguments(CTSD,
+                                CTSD->getTemplateInstantiationArgs().asArray(),
+                                /*Final=*/false);
 
     if (auto *CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(CTSD)) {
       if (CTPSD->isMemberSpecialization())
@@ -404,10 +410,12 @@ struct TemplateInstantiationArgumentCollecter
     // If this class template specialization was instantiated from a
     // specialized member that is a class template, we're done.
     assert(CTSD->getSpecializedTemplate() && "No class template?");
-    llvm::PointerUnion<ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl *>
+    llvm::PointerUnion<ClassTemplateDecl *,
+                       ClassTemplatePartialSpecializationDecl *>
         Specialized = CTSD->getSpecializedTemplateOrPartial();
 
-    if (auto *CTPSD = Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
+    if (auto *CTPSD =
+            Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
       if (CTPSD->isMemberSpecialization())
         return Done();
     } else {
@@ -418,9 +426,10 @@ struct TemplateInstantiationArgumentCollecter
     return DontClearRelativeToPrimaryNextDecl(CTSD);
   }
 
-  Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VTSD) {
-    // For a class-scope explicit specialization, there are no template arguments
-    // at this level, but there may be enclosing template arguments.
+  Decl *
+  VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *VTSD) {
+    // For a class-scope explicit specialization, there are no template
+    // arguments at this level, but there may be enclosing template arguments.
     if (VTSD->isClassScopeExplicitSpecialization() &&
         !isa<VarTemplatePartialSpecializationDecl>(VTSD))
       return DontClearRelativeToPrimaryNextDecl(VTSD);
@@ -431,11 +440,11 @@ struct TemplateInstantiationArgumentCollecter
       return Done();
 
     if (Innermost)
-        AddInnermostTemplateArguments(VTSD);
+      AddInnermostTemplateArguments(VTSD);
     else
-      AddOuterTemplateArguments(
-          VTSD, VTSD->getTemplateInstantiationArgs().asArray(),
-          /*Final=*/false);
+      AddOuterTemplateArguments(VTSD,
+                                VTSD->getTemplateInstantiationArgs().asArray(),
+                                /*Final=*/false);
 
     if (auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(VTSD)) {
       if (VTPSD->isMemberSpecialization())
@@ -445,9 +454,11 @@ struct TemplateInstantiationArgumentCollecter
     // If this variable template specialization was instantiated from a
     // specialized member that is a variable template, we're done.
     assert(VTSD->getSpecializedTemplate() && "No variable template?");
-    llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
+    llvm::PointerUnion<VarTemplateDecl *,
+                       VarTemplatePartialSpecializationDecl *>
         Specialized = VTSD->getSpecializedTemplateOrPartial();
-    if (auto *VTPSD = Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
+    if (auto *VTPSD =
+            Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
       if (VTPSD->isMemberSpecialization())
         return Done();
     } else {
@@ -458,10 +469,10 @@ struct TemplateInstantiationArgumentCollecter
     return DontClearRelativeToPrimaryNextDecl(VTSD);
   }
 
-  Decl *VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl *ICSD) {
-    AddOuterTemplateArguments(
-        ICSD, ICSD->getTemplateArguments(),
-        /*Final=*/false);
+  Decl *VisitImplicitConceptSpecializationDecl(
+      ImplicitConceptSpecializationDecl *ICSD) {
+    AddOuterTemplateArguments(ICSD, ICSD->getTemplateArguments(),
+                              /*Final=*/false);
     return UseNextDecl(ICSD);
   }
 
@@ -486,8 +497,8 @@ struct TemplateInstantiationArgumentCollecter
 
 MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
     const NamedDecl *ND, const DeclContext *DC, bool Final,
-    std::optional<ArrayRef<TemplateArgument>> Innermost,
-    bool RelativeToPrimary, bool ForConstraintInstantiation) {
+    std::optional<ArrayRef<TemplateArgument>> Innermost, bool RelativeToPrimary,
+    bool ForConstraintInstantiation) {
   assert((ND || DC) && "Can't find arguments for a decl if one isn't provided");
   // Accumulate the set of template argument lists in this structure.
   MultiLevelTemplateArgumentList Result;
@@ -497,8 +508,7 @@ MultiLevelTemplateArgumentList Sema::getTemplateInstantiationArgs(
     CurDecl = Decl::castFromDeclContext(DC);
 
   TemplateInstantiationArgumentCollecter Collecter(
-      *this, Result, Innermost, RelativeToPrimary,
-      ForConstraintInstantiation);
+      *this, Result, Innermost, RelativeToPrimary, ForConstraintInstantiation);
   do {
     CurDecl = Collecter.Visit(const_cast<Decl *>(CurDecl));
   } while (CurDecl);
@@ -1630,11 +1640,11 @@ namespace {
 
     ExprResult RebuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
                                  LambdaScopeInfo *LSI) {
-      #if 1
+#if 1
       CXXMethodDecl *MD = LSI->CallOperator;
       // if (MD->getParentFunctionOrMethod()) {
       if (true) {
-      #if 0
+#if 0
         NamedDecl *Pattern = MD;
           std::optional<ArrayRef<TemplateArgument>> Innermost;
         if (FunctionTemplateDecl *FTD = MD->getDescribedFunctionTemplate()) {
@@ -1645,8 +1655,8 @@ namespace {
             SemaRef.getTemplateInstantiationArgs(Pattern, Pattern->getLexicalDeclContext(),
                                                  /*Final=*/false, Innermost,
                                                  /*RelativeToPrimary=*/true);
-        #endif
-;
+#endif
+        ;
         for (ParmVarDecl *PVD : MD->parameters()) {
           assert(PVD && "null in a parameter list");
           if (!PVD->hasDefaultArg())
@@ -1660,13 +1670,13 @@ namespace {
             // that downstream diagnostics are omitted.
             ExprResult ErrorResult = SemaRef.CreateRecoveryExpr(
                 UninstExpr->getBeginLoc(), UninstExpr->getEndLoc(),
-                { UninstExpr }, UninstExpr->getType());
+                {UninstExpr}, UninstExpr->getType());
             if (ErrorResult.isUsable())
               PVD->setDefaultArg(ErrorResult.get());
           }
         }
       }
-      #endif
+#endif
       return inherited::RebuildLambdaExpr(StartLoc, EndLoc, LSI);
     }
 
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 974943e5df..0463852e28 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -20,8 +20,8 @@
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
-#include "clang/AST/TypeOrdering.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
@@ -4686,7 +4686,8 @@ bool Sema::InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
   NamedDecl *Pattern = FD;
   std::optional<ArrayRef<TemplateArgument>> Innermost;
 
-  if (FD->isCXXClassMember() && !isGenericLambdaCallOperatorOrStaticInvokerSpecialization(FD)) {
+  if (FD->isCXXClassMember() &&
+      !isGenericLambdaCallOperatorOrStaticInvokerSpecialization(FD)) {
     if (FunctionTemplateDecl *FTD = FD->getPrimaryTemplate()) {
       Pattern = FTD->getFirstDecl();
       Innermost = FD->getTemplateSpecializationArgs()->asArray();
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 9b99a577c0..b3606129cc 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -9951,7 +9951,8 @@ void ASTReader::finishPendingActions() {
 
     auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
     for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
-      cast<RedeclarableTemplateDecl>(R)->Common.setPointer(RTD->Common.getPointer());
+      cast<RedeclarableTemplateDecl>(R)->Common.setPointer(
+          RTD->Common.getPointer());
   }
   PendingDefinitions.clear();
 
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index 618aa65c2e..c91f156cb5 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -2567,7 +2567,7 @@ void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(
-      readDeclAs<ClassTemplatePartialSpecializationDecl>());
+        readDeclAs<ClassTemplatePartialSpecializationDecl>());
   }
 }
 
@@ -2660,7 +2660,7 @@ void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
   D->TemplateParams = Params;
 
   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
-    D->InstantiatedFromMember.setInt(Record.readInt());
+  D->InstantiatedFromMember.setInt(Record.readInt());
 
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {

``````````

</details>


https://github.com/llvm/llvm-project/pull/106585


More information about the cfe-commits mailing list