[Clang] Make constraints of auto part of NTTP instead of AutoType

[ychen]

Summary

Why do this

While working on D128750, it is found that AutoType is not uniqued as expected in the partial ordering. This is because
AutoType contains the constraints for the NTTP and the NTTP itself has a reference to the constraint in AutoType.
Due to this restriction, the partial ordering between template<C auto> and template<D auto> could not be handled the same way
as the partial ordering between template<int> and template<int>. By P2113, they should work the same way and if it doesn't,
the implementation of P2113 would be much harder if at all possible. After this patch, NTTP constraints operate the same way as
TTP constraints, which is to say, constraints are represented separately from the type. This is also easier to understand and maintain.

Note that this patch only changes how constrained auto is represented in NTTP. Nothing is changed when
constrained auto is used as function parameters, as variable declarations, etc.

Implementation strategy

• Add a TypeConstraint to NonTypeTemplateParmDecl in the same way as TemplateTypeParmDecl
• During parsing, parse the constraint as a part of NTTP. This also means the constraint inside AutoType would be empty (and later in partial ordering, AutoType uniquing would work due to this).
• Looking at how the constraint for TemplateTypeParmDecl is handled, add similar/same handling for the constraint for NonTypeTemplateParmDecl.

AST change

For (TTP W is added for comparison purposes.)

template <typename T> concept C = true;
template<C auto V, C W> struct A;

AST before this patch:

`-ClassTemplateDecl 0x9091c60 <line:2:1, col:32> col:32 A
  |-NonTypeTemplateParmDecl 0x9091818 <col:10, col:17> col:17 referenced 'C auto' depth 0 index 0 V    ========> C is part of AutoType
  | `-ConceptSpecializationExpr 0x9091948 <col:10> 'bool' Concept 0x90916e8 'C'
  |   `-TemplateArgument <col:17> type 'decltype(V)'
  |     `-DecltypeType 0x90918e0 'decltype(V)' dependent
  |       `-DeclRefExpr 0x9091878 <col:17> 'C auto' NonTypeTemplateParm 0x9091818 'V' 'C auto'
  |-TemplateTypeParmDecl 0x90919d0 <col:20, col:22> col:22 Concept 0x90916e8 'C' depth 0 index 1 W
  | `-ConceptSpecializationExpr 0x9091b08 <col:20> 'bool' Concept 0x90916e8 'C'
  |   `-TemplateArgument <col:22> type 'W'
  |     `-TemplateTypeParmType 0x9091aa0 'W' dependent depth 0 index 1
  |       `-TemplateTypeParm 0x90919d0 'W'
  `-CXXRecordDecl 0x9091bb0 <col:25, col:32> col:32 struct A

AST after this patch:

`-ClassTemplateDecl 0x887dd40 <line:2:1, col:32> col:32 A
  |-NonTypeTemplateParmDecl 0x887d8b8 <col:12, col:17> col:17 referenced Concept 0x887d788 'C' 'auto' depth 0 index 0 V   ========> C is part of NTTP
  | `-ConceptSpecializationExpr 0x887da28 <col:10> 'bool' Concept 0x887d788 'C'
  |   `-TemplateArgument <col:17> type 'decltype(V)'
  |     `-DecltypeType 0x887d9c0 'decltype(V)' dependent
  |       `-DeclRefExpr 0x887d960 <col:17> 'auto' NonTypeTemplateParm 0x887d8b8 'V' 'auto'
  |-TemplateTypeParmDecl 0x887dab0 <col:20, col:22> col:22 Concept 0x887d788 'C' depth 0 index 1 W
  | `-ConceptSpecializationExpr 0x887dbe8 <col:20> 'bool' Concept 0x887d788 'C'
  |   `-TemplateArgument <col:22> type 'W'
  |     `-TemplateTypeParmType 0x887db80 'W' dependent depth 0 index 1
  |       `-TemplateTypeParm 0x887dab0 'W'
  `-CXXRecordDecl 0x887dc90 <col:25, col:32> col:32 struct A

[rsmith]

I'm somewhat skeptical of this approach, because constrained auto can appear in places within the type of an NTTP other than the top level -- for example, in template<C auto*>. (Clang is non-conforming and doesn't support this yet, but it will need to do so eventually.) In principle, there could even be multiple different constrained auto types within the type of the same NTTP in the future -- I don't think that can happen with the current language rules, but it could happen in the Concepts TS, and it only seems to be happenstance that prevents it in C++20 rather than design intent. Fundamentally, the constraint is not associated with the NTTP and is instead associated with the relevant portion of the NTTP's type. If something in the design of constrained auto is meaning that uniquing isn't working properly, maybe there's some way we can address that directly?

[mizvekov]

I don't think the problem here is an uniquing problem per se, it's just that the constraints are part of the canonical type of undeduced auto, which is undesirable for the NTTP.

Maybe it would work to just add a new flag parameter to ASTContext::getAutoType which makes it not add the constraints to the canonical type?

It is odd that the handling for TTP and NTTP is different here, but perhaps we could move TTP to this solution as well?

[ychen]

@rsmith, thanks for chiming in.

In D134772#3819502, @rsmith wrote:

I'm somewhat skeptical of this approach, because constrained auto can appear in places within the type of an NTTP other than the top level -- for example, in template<C auto*>. (Clang is non-conforming and doesn't support this yet, but it will need to do so eventually.)

Yep, I'm aware of the cases like template<C auto*>/template<C auto&>/template<C decltype(auto)>. It would need to retrieve the deduced type explicitly and the difference this patch brings is to look for the constraints from NTTP instead. It is not geat but doable.

In principle, there could even be multiple different constrained auto types within the type of the same NTTP in the future -- I don't think that can happen with the current language rules, but it could happen in the Concepts TS, and it only seems to be happenstance that prevents it in C++20 rather than design intent. Fundamentally, the constraint is not associated with the NTTP and is instead associated with the relevant portion of the NTTP's type.

I fully agree that fundamentally the constraint is associated with auto (the syntax rule suggests that too). I didn't think of the possibility that multiple different constrained auto types within the type of the same NTTP. It is very interesting. Any chance this approach could be tuned for that future use case? Like maintaining an array of constrains for the NTTP?

If something in the design of constrained auto is meaning that uniquing isn't working properly, maybe there's some way we can address that directly?

I gave a lot of thought to it but couldn't find a satisfactory approach. One way is to recreate injected template argument for constrained auto NTTP, but without the constraint, then use that the instantiate all the types I need for the partial ordering. It is definitely doable but pretty expensive. Any suggestions are greatly appreciated. :-)

[ychen]

In D134772#3819551, @mizvekov wrote:

I don't think the problem here is an uniquing problem per se, it's just that the constraints are part of the canonical type of undeduced auto, which is undesirable for the NTTP.

Maybe it would work to just add a new flag parameter to ASTContext::getAutoType which makes it not add the constraints to the canonical type?

Hmm. That sounds promising to me. Let me see if I could get this to work. Thanks.

It is odd that the handling for TTP and NTTP is different here, but perhaps we could move TTP to this solution as well?

Yeah, it is odd from the POV of template handling. From the type hierarchy POV, it is consistent because TTP is a type and auto is also a type. I guess ultimately we choose the one that is easy and extensible for future language features.

[ychen]

D135088 was landed instead.

clang/include/clang/AST/ASTNodeTraverser.h

if (const auto *TC = D->getTypeConstraint())
       Visit(TC->getImmediatelyDeclaredConstraint());
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),
             D->defaultArgumentWasInherited() ? "inherited from" : "previous");
   }
 
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
-    if (const auto *E = D->getPlaceholderTypeConstraint())
-      Visit(E);
+    if (const auto *TC = D->getPlaceholderTypeConstraint())
+      Visit(TC->getImmediatelyDeclaredConstraint());
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),
             D->defaultArgumentWasInherited() ? "inherited from" : "previous");
   }
 
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());

clang/include/clang/AST/DeclTemplate.h

 /// @code
 /// template<int Size> class array { };
 /// @endcode
 class NonTypeTemplateParmDecl final
     : public DeclaratorDecl,
       protected TemplateParmPosition,
       private llvm::TrailingObjects<NonTypeTemplateParmDecl,
                                     std::pair<QualType, TypeSourceInfo *>,
-                                    Expr *> {
+                                    TypeConstraint> {
   friend class ASTDeclReader;
   friend TrailingObjects;
 
   /// The default template argument, if any, and whether or not
   /// it was inherited.
   using DefArgStorage = DefaultArgStorage<NonTypeTemplateParmDecl, Expr *>;
   DefArgStorage DefaultArgument;
 
   // FIXME: Collapse this into TemplateParamPosition; or, just move depth/index
   // down here to save memory.
 
   /// Whether this non-type template parameter is a parameter pack.
-  bool ParameterPack;
+  bool ParameterPack : 1;
+
+  /// Whether this template type parameter has a type-constraint construct.
+  bool HasTypeConstraint : 1;
+
+  /// Whether the type constraint has been initialized. This can be false if the
+  /// constraint was not initialized yet or if there was an error forming the
+  /// type constraint.
+  bool TypeConstraintInitialized : 1;
 
   /// Whether this non-type template parameter is an "expanded"
   /// parameter pack, meaning that its type is a pack expansion and we
   /// already know the set of types that expansion expands to.
-  bool ExpandedParameterPack = false;
+  bool ExpandedParameterPack : 1;
 
   /// The number of types in an expanded parameter pack.
   unsigned NumExpandedTypes = 0;
 
   size_t numTrailingObjects(
       OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
     return NumExpandedTypes;
   }
 
   NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
                           SourceLocation IdLoc, unsigned D, unsigned P,
-                          IdentifierInfo *Id, QualType T,
-                          bool ParameterPack, TypeSourceInfo *TInfo)
+                          IdentifierInfo *Id, QualType T, bool ParameterPack,
+                          bool HasTypeConstraint, TypeSourceInfo *TInfo)
       : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
-        TemplateParmPosition(D, P), ParameterPack(ParameterPack) {}
+        TemplateParmPosition(D, P), ParameterPack(ParameterPack),
+        HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false),
+        ExpandedParameterPack(false) {}
 
   NonTypeTemplateParmDecl(DeclContext *DC, SourceLocation StartLoc,
                           SourceLocation IdLoc, unsigned D, unsigned P,
                           IdentifierInfo *Id, QualType T,
-                          TypeSourceInfo *TInfo,
+                          bool HasTypeConstraint, TypeSourceInfo *TInfo,
                           ArrayRef<QualType> ExpandedTypes,
                           ArrayRef<TypeSourceInfo *> ExpandedTInfos);
 
 public:
   static NonTypeTemplateParmDecl *
   Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
          SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
-         QualType T, bool ParameterPack, TypeSourceInfo *TInfo);
+         QualType T, bool ParameterPack, bool HasTypeConstraint,
+         TypeSourceInfo *TInfo);
 
   static NonTypeTemplateParmDecl *
   Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
          SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
-         QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
+         QualType T, bool HasTypeConstraint, TypeSourceInfo *TInfo,
+         ArrayRef<QualType> ExpandedTypes,
          ArrayRef<TypeSourceInfo *> ExpandedTInfos);
 
   static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
                                                      unsigned ID,
                                                      bool HasTypeConstraint);
   static NonTypeTemplateParmDecl *CreateDeserialized(ASTContext &C,
                                                      unsigned ID,
                                                      unsigned NumExpandedTypes,
public:
   /// expanded parameter pack.
   TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
     assert(I < NumExpandedTypes && "Out-of-range expansion type index");
     auto TypesAndInfos =
         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     return TypesAndInfos[I].second;
   }
 
-  /// Return the constraint introduced by the placeholder type of this non-type
-  /// template parameter (if any).
-  Expr *getPlaceholderTypeConstraint() const {
-    return hasPlaceholderTypeConstraint() ? *getTrailingObjects<Expr *>() :
+  /// Returns the type constraint associated with this template parameter (if
+  /// any).
+  const TypeConstraint *getPlaceholderTypeConstraint() const {
+    return TypeConstraintInitialized ? getTrailingObjects<TypeConstraint>() :
          nullptr;
   }
 
-  void setPlaceholderTypeConstraint(Expr *E) {
-    *getTrailingObjects<Expr *>() = E;
-  }
+  void setPlaceholderTypeConstraint(NestedNameSpecifierLoc NNS,
+                         DeclarationNameInfo NameInfo, NamedDecl *FoundDecl,
+                         ConceptDecl *CD,
+                         const ASTTemplateArgumentListInfo *ArgsAsWritten,
+                         Expr *ImmediatelyDeclaredConstraint);
 
-  /// Determine whether this non-type template parameter's type has a
-  /// placeholder with a type-constraint.
+  /// Determine whether this template parameter has a type-constraint.
   bool hasPlaceholderTypeConstraint() const {
-    auto *AT = getType()->getContainedAutoType();
-    return AT && AT->isConstrained();
+    return HasTypeConstraint;
   }
 
   /// \brief Get the associated-constraints of this template parameter.
-  /// This will either be a vector of size 1 containing the immediately-declared
-  /// constraint introduced by the placeholder type, or an empty vector.
+  /// This will either be the immediately-introduced constraint or empty.
   ///
-  /// Use this instead of getPlaceholderImmediatelyDeclaredConstraint for
-  /// concepts APIs that accept an ArrayRef of constraint expressions.
+  /// Use this instead of getPlaceholderTypeConstraint for concepts APIs that
+  /// accept an ArrayRef of constraint expressions.
   void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
-    if (Expr *E = getPlaceholderTypeConstraint())
-      AC.push_back(E);
+    if (HasTypeConstraint)
+      AC.push_back(
+          getPlaceholderTypeConstraint()->getImmediatelyDeclaredConstraint());
   }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
 };
 
 /// TemplateTemplateParmDecl - Declares a template template parameter,

clang/include/clang/AST/RecursiveASTVisitor.h

private:
   /// reference.
   bool TraverseConceptReferenceHelper(const ConceptReference &C);
 
   // Traverses template parameter lists of either a DeclaratorDecl or TagDecl.
   template <typename T>
   bool TraverseDeclTemplateParameterLists(T *D);
 
   bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);
+  bool TraverseTemplateTypeParamDeclConstraints(const NonTypeTemplateParmDecl *D);
 
   bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
                                           unsigned Count);
   bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
   bool TraverseRecordHelper(RecordDecl *D);
   bool TraverseCXXRecordHelper(CXXRecordDecl *D);
   bool TraverseDeclaratorHelper(DeclaratorDecl *D);
   bool TraverseDeclContextHelper(DeclContext *DC);

 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
     const TemplateTypeParmDecl *D) {
   if (const auto *TC = D->getTypeConstraint())
     TRY_TO(TraverseTypeConstraint(TC));
   return true;
 }
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
+    const NonTypeTemplateParmDecl *D) {
+  if (const auto *TC = D->getPlaceholderTypeConstraint())
+    TRY_TO(TraverseTypeConstraint(TC));
+  return true;
+}
+
 DEF_TRAVERSE_DECL(TemplateTypeParmDecl, {
   // D is the "T" in something like "template<typename T> class vector;"
   if (D->getTypeForDecl())
     TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
   TRY_TO(TraverseTemplateTypeParamDeclConstraints(D));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
 })
bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
   return true;
 }
 
 DEF_TRAVERSE_DECL(VarDecl, { TRY_TO(TraverseVarHelper(D)); })
 
 DEF_TRAVERSE_DECL(ImplicitParamDecl, { TRY_TO(TraverseVarHelper(D)); })
 
 DEF_TRAVERSE_DECL(NonTypeTemplateParmDecl, {
+  TRY_TO(TraverseTemplateTypeParamDeclConstraints(D));
   // A non-type template parameter, e.g. "S" in template<int S> class Foo ...
   TRY_TO(TraverseDeclaratorHelper(D));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseStmt(D->getDefaultArgument()));
 })
 
 DEF_TRAVERSE_DECL(ParmVarDecl, {
   TRY_TO(TraverseVarHelper(D));

clang/include/clang/Sema/Sema.h

NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
                                 IdentifierInfo *ParamName,
                                 SourceLocation ParamNameLoc,
                                 unsigned Depth, unsigned Position,
                                 SourceLocation EqualLoc,
                                 ParsedType DefaultArg, bool HasTypeConstraint);
 
   bool ActOnTypeConstraint(const CXXScopeSpec &SS,
                            TemplateIdAnnotation *TypeConstraint,
-                           TemplateTypeParmDecl *ConstrainedParameter,
+                           NamedDecl *ConstrainedParameter,
                            SourceLocation EllipsisLoc);
   bool BuildTypeConstraint(const CXXScopeSpec &SS,
                            TemplateIdAnnotation *TypeConstraint,
-                           TemplateTypeParmDecl *ConstrainedParameter,
+                           NamedDecl *ConstrainedParameter,
                            SourceLocation EllipsisLoc,
                            bool AllowUnexpandedPack);
-
   bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
                             DeclarationNameInfo NameInfo,
                             ConceptDecl *NamedConcept,
                             const TemplateArgumentListInfo *TemplateArgs,
                             TemplateTypeParmDecl *ConstrainedParameter,
                             SourceLocation EllipsisLoc);
-
-  bool AttachTypeConstraint(AutoTypeLoc TL,
-                            NonTypeTemplateParmDecl *ConstrainedParameter,
+  bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
+                            DeclarationNameInfo NameInfo,
+                            ConceptDecl *NamedConcept,
+                            const TemplateArgumentListInfo *TemplateArgs,
+                            NonTypeTemplateParmDecl *NTTP,
                             SourceLocation EllipsisLoc);
 
   bool RequireStructuralType(QualType T, SourceLocation Loc);
 
   QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
                                              SourceLocation Loc);
   QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
 
   NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
                                       unsigned Depth,
                                       unsigned Position,
                                       SourceLocation EqualLoc,
-                                      Expr *DefaultArg);
+                                      Expr *DefaultArg, bool HasTypeConstraint);
   NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
                                        SourceLocation TmpLoc,
                                        TemplateParameterList *Params,
                                        SourceLocation EllipsisLoc,
                                        IdentifierInfo *ParamName,
                                        SourceLocation ParamNameLoc,
                                        unsigned Depth,
                                        unsigned Position,

   TemplateName
   SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
                     SourceLocation Loc,
                     const MultiLevelTemplateArgumentList &TemplateArgs);
 
   bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
                            const MultiLevelTemplateArgumentList &TemplateArgs,
                            bool EvaluateConstraint);
+  bool SubstTypeConstraint(NonTypeTemplateParmDecl *Inst,
+                           const TypeConstraint *TC,
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           SourceLocation EllipsisLoc, bool EvaluateConstraint);
 
   bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
                                   ParmVarDecl *Param);
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
   bool CheckInstantiatedFunctionTemplateConstraints(
       SourceLocation PointOfInstantiation, FunctionDecl *Decl,
       ArrayRef<TemplateArgument> TemplateArgs,

clang/lib/AST/ASTContext.cpp

if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
       } else
         ID.AddBoolean(false);
       continue;
     }
 
     if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
       ID.AddInteger(1);
       ID.AddBoolean(NTTP->isParameterPack());
+      const TypeConstraint *TC = NTTP->getPlaceholderTypeConstraint();
+      ID.AddBoolean(TC != nullptr);
+      if (TC)
+        TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
+                                                        /*Canonical=*/true);
       ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
       if (NTTP->isExpandedParameterPack()) {
         ID.AddBoolean(true);
         ID.AddInteger(NTTP->getNumExpansionTypes());
         for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
           QualType T = NTTP->getExpansionType(I);
           ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
         }
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
         SmallVector<QualType, 2> ExpandedTypes;
         SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
         for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
           ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
           ExpandedTInfos.push_back(
                                 getTrivialTypeSourceInfo(ExpandedTypes.back()));
         }
 
-        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
-                                                SourceLocation(),
-                                                SourceLocation(),
-                                                NTTP->getDepth(),
-                                                NTTP->getPosition(), nullptr,
-                                                T,
-                                                TInfo,
-                                                ExpandedTypes,
-                                                ExpandedTInfos);
+        Param = NonTypeTemplateParmDecl::Create(
+            *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+            NTTP->getDepth(), NTTP->getPosition(), nullptr, T,
+            NTTP->hasPlaceholderTypeConstraint(), TInfo, ExpandedTypes,
       } else {
-        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
-                                                SourceLocation(),
-                                                SourceLocation(),
-                                                NTTP->getDepth(),
-                                                NTTP->getPosition(), nullptr,
-                                                T,
-                                                NTTP->isParameterPack(),
-                                                TInfo);
+        Param = NonTypeTemplateParmDecl::Create(
+            *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+            NTTP->getDepth(), NTTP->getPosition(), nullptr, T,
+            NTTP->isParameterPack(), NTTP->hasPlaceholderTypeConstraint(),
       }
-      if (AutoType *AT = T->getContainedAutoType()) {
-        if (AT->isConstrained()) {
-          Param->setPlaceholderTypeConstraint(
-              canonicalizeImmediatelyDeclaredConstraint(
-                  *this, NTTP->getPlaceholderTypeConstraint(), T));
-        }
+      if (const auto *TC = NTTP->getPlaceholderTypeConstraint()) {
+        Expr *NewIDC = canonicalizeImmediatelyDeclaredConstraint(
+            *this, TC->getImmediatelyDeclaredConstraint(), NTTP->getType());
+            NestedNameSpecifierLoc(),
+            DeclarationNameInfo(TC->getNamedConcept()->getDeclName(),
+                                SourceLocation()),
+            /*FoundDecl=*/nullptr,
+            // Actually canonicalizing a TemplateArgumentLoc is difficult so we
+            // simply omit the ArgsAsWritten
+            TC->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);
       }
       CanonParams.push_back(Param);
 
     } else
       CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
                                            cast<TemplateTemplateParmDecl>(*P)));
   }
 
if (TX->hasTypeConstraint() != TY->hasTypeConstraint())
       return false;
     return isSameTypeConstraint(TX->getTypeConstraint(),
                                 TY->getTypeConstraint());
   }
 
   if (auto *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
     auto *TY = cast<NonTypeTemplateParmDecl>(Y);
     return TX->isParameterPack() == TY->isParameterPack() &&
-           TX->getASTContext().hasSameType(TX->getType(), TY->getType());
+           TX->getASTContext().hasSameType(TX->getType(), TY->getType()) &&
+           TX->hasPlaceholderTypeConstraint() ==
+               TY->hasPlaceholderTypeConstraint() &&
+           isSameTypeConstraint(TX->getPlaceholderTypeConstraint(),
+                                TY->getPlaceholderTypeConstraint());
   }
 
   auto *TX = cast<TemplateTemplateParmDecl>(X);
   auto *TY = cast<TemplateTemplateParmDecl>(Y);
   return TX->isParameterPack() == TY->isParameterPack() &&
          isSameTemplateParameterList(TX->getTemplateParameters(),
                                      TY->getTemplateParameters());
 }

clang/lib/AST/ASTImporter.cpp

ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   auto ToLocation = importChecked(Err, D->getLocation());
   auto ToType = importChecked(Err, D->getType());
   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
   if (Err)
     return std::move(Err);
 
   NonTypeTemplateParmDecl *ToD = nullptr;
-  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(),
-                              Importer.getToContext().getTranslationUnitDecl(),
-                              ToInnerLocStart, ToLocation, D->getDepth(),
-                              D->getPosition(),
-                              ToDeclName.getAsIdentifierInfo(), ToType,
-                              D->isParameterPack(), ToTypeSourceInfo))
+  if (GetImportedOrCreateDecl(
+          ToD, D, Importer.getToContext(),
+          Importer.getToContext().getTranslationUnitDecl(), ToInnerLocStart,
+          ToLocation, D->getDepth(), D->getPosition(),
+          ToDeclName.getAsIdentifierInfo(), ToType, D->isParameterPack(),
+          D->hasPlaceholderTypeConstraint(), ToTypeSourceInfo))
     return ToD;
 
+  // Import the type-constraint
+  if (const TypeConstraint *TC = D->getPlaceholderTypeConstraint()) {
+
+    Error Err = Error::success();
+    auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
+    auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
+    auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
+    auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
+    auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
+    auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
+    if (Err)
+      return std::move(Err);
+
+    TemplateArgumentListInfo ToTAInfo;
+    const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
+    if (ASTTemplateArgs)
+      if (Error Err =
+              ImportTemplateArgumentListInfo(*ASTTemplateArgs, ToTAInfo))
+        return std::move(Err);
+
+    ToD->setPlaceholderTypeConstraint(
+        ToNNS, DeclarationNameInfo(ToName, ToNameLoc), ToFoundDecl,
+        ToNamedConcept,
+        ASTTemplateArgs ? ASTTemplateArgumentListInfo::Create(
+                              Importer.getToContext(), ToTAInfo)
+                        : nullptr,
+        ToIDC);
+  }
+
   if (D->hasDefaultArgument()) {
     ExpectedExpr ToDefaultArgOrErr = import(D->getDefaultArgument());
     if (!ToDefaultArgOrErr)
       return ToDefaultArgOrErr.takeError();
     ToD->setDefaultArgument(*ToDefaultArgOrErr);
   }
 
   return ToD;

clang/lib/AST/DeclPrinter.cpp

void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
   if (TTP->hasDefaultArgument()) {
     Out << " = ";
     Out << TTP->getDefaultArgument().getAsString(Policy);
   }
 }
 
 void DeclPrinter::VisitNonTypeTemplateParmDecl(
     const NonTypeTemplateParmDecl *NTTP) {
+  if (const TypeConstraint *TC = NTTP->getPlaceholderTypeConstraint())
+    TC->print(Out, Policy);
   StringRef Name;
   if (IdentifierInfo *II = NTTP->getIdentifier())
     Name =
         Policy.CleanUglifiedParameters ? II->deuglifiedName() : II->getName();
   printDeclType(NTTP->getType(), Name, NTTP->isParameterPack());
 
   if (NTTP->hasDefaultArgument()) {
     Out << " = ";
     NTTP->getDefaultArgument()->printPretty(Out, nullptr, Policy, Indentation,
                                             "\n", &Context);
   }
 }

clang/lib/AST/DeclTemplate.cpp

 void TemplateParameterList::
 getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
   if (HasConstrainedParameters)
     for (const NamedDecl *Param : *this) {
       if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
         if (const auto *TC = TTP->getTypeConstraint())
           AC.push_back(TC->getImmediatelyDeclaredConstraint());
       } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
-        if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
-          AC.push_back(E);
+        if (const auto *TC = NTTP->getPlaceholderTypeConstraint())
+          AC.push_back(TC->getImmediatelyDeclaredConstraint());
       }
     }
   if (HasRequiresClause)
     AC.push_back(getRequiresClause());
 }
 
 bool TemplateParameterList::hasAssociatedConstraints() const {
   return HasRequiresClause || HasConstrainedParameters;
static void ProfileTemplateParameterList(ASTContext &C,
   ID.AddBoolean(RC != nullptr);
   if (RC)
     RC->Profile(ID, C, /*Canonical=*/true);
   ID.AddInteger(TPL->size());
   for (NamedDecl *D : *TPL) {
     if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
       ID.AddInteger(0);
       ID.AddBoolean(NTTP->isParameterPack());
+      ID.AddBoolean(NTTP->hasPlaceholderTypeConstraint());
+      if (const TypeConstraint *TC = NTTP->getPlaceholderTypeConstraint())
+        TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
+                                                        /*Canonical=*/true);
       NTTP->getType().getCanonicalType().Profile(ID);
       continue;
     }
     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
       ID.AddInteger(1);
       ID.AddBoolean(TTP->isParameterPack());
       ID.AddBoolean(TTP->hasTypeConstraint());
       if (const TypeConstraint *TC = TTP->getTypeConstraint())

 }
 
 //===----------------------------------------------------------------------===//
 // NonTypeTemplateParmDecl Method Implementations
 //===----------------------------------------------------------------------===//
 
 NonTypeTemplateParmDecl::NonTypeTemplateParmDecl(
     DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D,
-    unsigned P, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
-    ArrayRef<QualType> ExpandedTypes, ArrayRef<TypeSourceInfo *> ExpandedTInfos)
+    unsigned P, IdentifierInfo *Id, QualType T, bool HasTypeConstraint,
+    TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
+    ArrayRef<TypeSourceInfo *> ExpandedTInfos)
     : DeclaratorDecl(NonTypeTemplateParm, DC, IdLoc, Id, T, TInfo, StartLoc),
       TemplateParmPosition(D, P), ParameterPack(true),
+      HasTypeConstraint(HasTypeConstraint), TypeConstraintInitialized(false),
       ExpandedParameterPack(true), NumExpandedTypes(ExpandedTypes.size()) {
   if (!ExpandedTypes.empty() && !ExpandedTInfos.empty()) {
     auto TypesAndInfos =
         getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     for (unsigned I = 0; I != NumExpandedTypes; ++I) {
       new (&TypesAndInfos[I].first) QualType(ExpandedTypes[I]);
       TypesAndInfos[I].second = ExpandedTInfos[I];
     }
   }
 }
 
 NonTypeTemplateParmDecl *
 NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
                                 SourceLocation StartLoc, SourceLocation IdLoc,
                                 unsigned D, unsigned P, IdentifierInfo *Id,
                                 QualType T, bool ParameterPack,
-                                TypeSourceInfo *TInfo) {
-  AutoType *AT =
-      C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
-  return new (C, DC,
-              additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                    Expr *>(0,
-                                            AT && AT->isConstrained() ? 1 : 0))
+                                bool HasTypeConstraint, TypeSourceInfo *TInfo) {
+  return new (
+      C, DC,
+                            TypeConstraint>(0, HasTypeConstraint ? 1 : 0))
       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
-                              TInfo);
+                              HasTypeConstraint, TInfo);
 }
 
 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
     const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
     SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
-    QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
+    QualType T, bool HasTypeConstraint, TypeSourceInfo *TInfo,
+    ArrayRef<QualType> ExpandedTypes,
     ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
-  AutoType *AT = TInfo->getType()->getContainedAutoType();
   return new (C, DC,
               additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                    Expr *>(
-                  ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
-      NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
-                              ExpandedTypes, ExpandedTInfos);
+                                    TypeConstraint>(ExpandedTypes.size(),
+                                                    HasTypeConstraint ? 1 : 0))
+      NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T,
+                              HasTypeConstraint, TInfo, ExpandedTypes,
+                              ExpandedTInfos);
 }
 
 NonTypeTemplateParmDecl *
 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                             bool HasTypeConstraint) {
-  return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
-                                                     TypeSourceInfo *>,
-                                           Expr *>(0,
-                                                   HasTypeConstraint ? 1 : 0))
-          NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
-                                  0, 0, nullptr, QualType(), false, nullptr);
+  return new (
+      C, ID,
+      additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
+                            TypeConstraint>(0, HasTypeConstraint ? 1 : 0))
+      NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), 0, 0,
+                              nullptr, QualType(), false, HasTypeConstraint,
+                              nullptr);
 }
 
 NonTypeTemplateParmDecl *
 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                             unsigned NumExpandedTypes,
                                             bool HasTypeConstraint) {
-  auto *NTTP =
-      new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                        Expr *>(
+  auto *NTTP = new (C, ID,
+                    additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
+                                          TypeConstraint>(
                         NumExpandedTypes, HasTypeConstraint ? 1 : 0))
-          NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
-                                  0, 0, nullptr, QualType(), nullptr, None,
-                                  None);
+      NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), 0, 0,
+                              nullptr, QualType(), HasTypeConstraint, nullptr,
+                              None, None);
   NTTP->NumExpandedTypes = NumExpandedTypes;
   return NTTP;
 }
 
 SourceRange NonTypeTemplateParmDecl::getSourceRange() const {
   if (hasDefaultArgument() && !defaultArgumentWasInherited())
     return SourceRange(getOuterLocStart(),
                        getDefaultArgument()->getSourceRange().getEnd());
   return DeclaratorDecl::getSourceRange();
 }
 
 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
   return hasDefaultArgument()
     ? getDefaultArgument()->getSourceRange().getBegin()
     : SourceLocation();
 }
 
+void NonTypeTemplateParmDecl::setPlaceholderTypeConstraint(
+    NestedNameSpecifierLoc NNS, DeclarationNameInfo NameInfo,
+    NamedDecl *FoundDecl, ConceptDecl *CD,
+    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    Expr *ImmediatelyDeclaredConstraint) {
+  assert(HasTypeConstraint &&
+         "HasTypeConstraint=true must be passed at construction in order to "
+         "call setTypeConstraint");
+  assert(!TypeConstraintInitialized &&
+         "TypeConstraint was already initialized!");
+  new (getTrailingObjects<TypeConstraint>())
+      TypeConstraint(NNS, NameInfo, FoundDecl, CD, ArgsAsWritten,
+                     ImmediatelyDeclaredConstraint);
+  TypeConstraintInitialized = true;
+}
+
 //===----------------------------------------------------------------------===//
 // TemplateTemplateParmDecl Method Implementations
 //===----------------------------------------------------------------------===//
 
 void TemplateTemplateParmDecl::anchor() {}
 
 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
auto *T = TemplateTypeParmDecl::Create(
       /*HasTypeConstraint=*/false);
   T->setImplicit(true);
 
   // T ...Ints
   TypeSourceInfo *TI =
       C.getTrivialTypeSourceInfo(QualType(T->getTypeForDecl(), 0));
   auto *N = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
-      /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true, TI);
+      /*Id=*/nullptr, TI->getType(), /*ParameterPack=*/true,
+      /*HasTypeConstraint=*/false, TI);
   N->setImplicit(true);
 
   // <typename T, T ...Ints>
   NamedDecl *P[2] = {T, N};
   auto *TPL = TemplateParameterList::Create(
       C, SourceLocation(), SourceLocation(), P, SourceLocation(), nullptr);
 
   // template <typename T, ...Ints> class IntSeq
auto *TemplateTypeParm = TemplateTypeParmDecl::Create(
       /*HasTypeConstraint=*/false);
   TemplateTypeParm->setImplicit(true);
 
   // T N
   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(
       QualType(TemplateTypeParm->getTypeForDecl(), 0));
   auto *NonTypeTemplateParm = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/2,
-      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
+      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false,
+      /*HasTypeConstraint=*/false, TInfo);
   NamedDecl *Params[] = {TemplateTemplateParm, TemplateTypeParm,
                          NonTypeTemplateParm};
 
   // template <template <typename T, T ...Ints> class IntSeq, typename T, T N>
   return TemplateParameterList::Create(C, SourceLocation(), SourceLocation(),
                                        Params, SourceLocation(), nullptr);
 }
 
 static TemplateParameterList *
 createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
   // std::size_t Index
   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
   auto *Index = NonTypeTemplateParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/0,
-      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false, TInfo);
+      /*Id=*/nullptr, TInfo->getType(), /*ParameterPack=*/false,
+      /*HasTypeConstraint=*/false, TInfo);
 
   // typename ...T
   auto *Ts = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/0, /*Position=*/1,
       /*Id=*/nullptr, /*Typename=*/true, /*ParameterPack=*/true,
       /*HasTypeConstraint=*/false);
   Ts->setImplicit(true);
 

clang/lib/AST/ODRHash.cpp

void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
     const bool hasDefaultArgument =
         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
     Hash.AddBoolean(hasDefaultArgument);
     if (hasDefaultArgument) {
       AddStmt(D->getDefaultArgument());
     }
     Hash.AddBoolean(D->isParameterPack());
 
+    const TypeConstraint *TC = D->getPlaceholderTypeConstraint();
+    Hash.AddBoolean(TC != nullptr);
+    if (TC)
+      AddStmt(TC->getImmediatelyDeclaredConstraint());
+
     Inherited::VisitNonTypeTemplateParmDecl(D);
   }
 
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
     // Only care about default arguments as part of the definition.
     const bool hasDefaultArgument =
         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
     Hash.AddBoolean(hasDefaultArgument);

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   dumpName(D);
 }
 
 void TextNodeDumper::VisitNonTypeTemplateParmDecl(
     const NonTypeTemplateParmDecl *D) {
+  if (const auto *TC = D->getPlaceholderTypeConstraint()) {
+    OS << " ";
+    dumpBareDeclRef(TC->getNamedConcept());
+    if (TC->getNamedConcept() != TC->getFoundDecl()) {
+      OS << " (";
+      dumpBareDeclRef(TC->getFoundDecl());
+      OS << ")";
+    }
+  }
   dumpType(D->getType());
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   dumpName(D);
 }
 
 void TextNodeDumper::VisitTemplateTemplateParmDecl(

clang/lib/Index/IndexDecl.cpp

for (const NamedDecl *TP : *Params) {
         if (TTP->hasDefaultArgument())
           IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
         if (auto *C = TTP->getTypeConstraint())
           IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
                                    Parent, TTP->getLexicalDeclContext());
       } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {
         if (NTTP->hasDefaultArgument())
           IndexCtx.indexBody(NTTP->getDefaultArgument(), Parent);
+        if (auto *C = NTTP->getPlaceholderTypeConstraint())
+          IndexCtx.handleReference(C->getNamedConcept(), C->getConceptNameLoc(),
+                                   Parent, NTTP->getLexicalDeclContext());
       } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(TP)) {
         if (TTPD->hasDefaultArgument())
           handleTemplateArgumentLoc(TTPD->getDefaultArgument(), Parent,
                                     TP->getLexicalDeclContext());
       }
     }
     if (auto *R = Params->getRequiresClause())
       IndexCtx.indexBody(R, Parent);

clang/lib/Parse/ParseTemplate.cpp

 //===--- ParseTemplate.cpp - Template Parsing -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements parsing of C++ templates.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
case TPResult::Error: {
     DeclSpec DS(getAttrFactory());
     DS.SetTypeSpecError();
     Declarator D(DS, ParsedAttributesView::none(),
                  DeclaratorContext::TemplateParam);
     D.SetIdentifier(nullptr, Tok.getLocation());
     D.setInvalidType(true);
     NamedDecl *ErrorParam = Actions.ActOnNonTypeTemplateParameter(
         getCurScope(), D, Depth, Position, /*EqualLoc=*/SourceLocation(),
-        /*DefaultArg=*/nullptr);
+        /*DefaultArg=*/nullptr, /*HasTypeConstraint=*/false);
     ErrorParam->setInvalidDecl(true);
     SkipUntil(tok::comma, tok::greater, tok::greatergreater,
               StopAtSemi | StopBeforeMatch);
     return ErrorParam;
   }
 
   case TPResult::Ambiguous:
     llvm_unreachable("template param classification can't be ambiguous");
NamedDecl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {
   NamedDecl *NewDecl = Actions.ActOnTypeParameter(getCurScope(),
                                                   TypenameKeyword, EllipsisLoc,
                                                   KeyLoc, ParamName, NameLoc,
                                                   Depth, Position, EqualLoc,
                                                   DefaultArg,
                                                   TypeConstraint != nullptr);
 
   if (TypeConstraint) {
-    Actions.ActOnTypeConstraint(TypeConstraintSS, TypeConstraint,
-                                cast<TemplateTypeParmDecl>(NewDecl),
+    Actions.ActOnTypeConstraint(TypeConstraintSS, TypeConstraint, NewDecl,
                                 EllipsisLoc);
   }
 
   return NewDecl;
 }
 
 /// ParseTemplateTemplateParameter - Handle the parsing of template
 /// template parameters.

 }
 
 /// ParseNonTypeTemplateParameter - Handle the parsing of non-type
 /// template parameters (e.g., in "template<int Size> class array;").
 ///
 ///       template-parameter:
 ///         ...
 ///         parameter-declaration
-NamedDecl *
-Parser::ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position) {
+NamedDecl *Parser::ParseNonTypeTemplateParameter(unsigned Depth,
+                                                 unsigned Position) {
+  // Consume the 'type-constraint'.
+  CXXScopeSpec TypeConstraintSS;
+  TemplateIdAnnotation *TypeConstraint = nullptr;
+  if (isTypeConstraintAnnotation()) {
+    ParseOptionalCXXScopeSpecifier(TypeConstraintSS, /*ObjectType=*/nullptr,
+                                   /*ObjectHasErrors=*/false,
+                                   /*EnteringContext*/ false);
+    TypeConstraint =
+        static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
+    ConsumeAnnotationToken();
+  }
+
   // Parse the declaration-specifiers (i.e., the type).
   // FIXME: The type should probably be restricted in some way... Not all
   // declarators (parts of declarators?) are accepted for parameters.
   DeclSpec DS(AttrFactory);
   ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
                              DeclSpecContext::DSC_template_param);
 
   // Parse this as a typename.
if (Tok.is(tok::l_paren) && NextToken().is(tok::l_brace)) {
       DefaultArg =
           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
       if (DefaultArg.isInvalid())
         SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
     }
   }
 
   // Create the parameter.
-  return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl,
-                                               Depth, Position, EqualLoc,
-                                               DefaultArg.get());
+  NamedDecl *NewDecl =  Actions.ActOnNonTypeTemplateParameter(
+      getCurScope(), ParamDecl, Depth, Position, EqualLoc, DefaultArg.get(), TypeConstraint);
+
+  if (TypeConstraint) {
+    // FIXME: diagnose if the constrained type is not auto.
+    Actions.ActOnTypeConstraint(TypeConstraintSS, TypeConstraint, NewDecl,
+                                ParamDecl.getEllipsisLoc());
+  }
+
+  return NewDecl;
 }
 
 void Parser::DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
                                        SourceLocation CorrectLoc,
                                        bool AlreadyHasEllipsis,
                                        bool IdentifierHasName) {
   FixItHint Insertion;
   if (!AlreadyHasEllipsis)

clang/lib/Sema/HLSLExternalSemaSource.cpp

auto *TypeParam = TemplateTypeParmDecl::Create(
       &AST.Idents.get("element", tok::TokenKind::identifier), false, false);
   TypeParam->setDefaultArgument(AST.getTrivialTypeSourceInfo(AST.FloatTy));
 
   TemplateParams.emplace_back(TypeParam);
 
   auto *SizeParam = NonTypeTemplateParmDecl::Create(
       AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 1,
       &AST.Idents.get("element_count", tok::TokenKind::identifier), AST.IntTy,
-      false, AST.getTrivialTypeSourceInfo(AST.IntTy));
+      false, false, AST.getTrivialTypeSourceInfo(AST.IntTy));
   Expr *LiteralExpr =
       IntegerLiteral::Create(AST, llvm::APInt(AST.getIntWidth(AST.IntTy), 4),
                              AST.IntTy, SourceLocation());
   SizeParam->setDefaultArgument(LiteralExpr);
   TemplateParams.emplace_back(SizeParam);
 
   auto *ParamList =
       TemplateParameterList::Create(AST, SourceLocation(), SourceLocation(),

clang/lib/Sema/SemaCodeComplete.cpp

if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
       if (TTP->getIdentifier()) {
         PlaceholderStr += ' ';
         PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
       }
 
       HasDefaultArg = TTP->hasDefaultArgument();
     } else if (NonTypeTemplateParmDecl *NTTP =
                    dyn_cast<NonTypeTemplateParmDecl>(*P)) {
+      if (const auto *TC = NTTP->getPlaceholderTypeConstraint()) {
+        llvm::raw_string_ostream OS(PlaceholderStr);
+        TC->print(OS, Policy);
+        OS.flush();
+      }
       if (NTTP->getIdentifier())
-        PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName());
+        PlaceholderStr += std::string(NTTP->getIdentifier()->deuglifiedName());
       NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
+
       HasDefaultArg = NTTP->hasDefaultArgument();
     } else {
       assert(isa<TemplateTemplateParmDecl>(*P));
       TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
 
       // Since putting the template argument list into the placeholder would
       // be very, very long, we just use an abbreviation.
       PlaceholderStr = "template<...> class";

clang/lib/Sema/SemaTemplate.cpp

 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/ErrorHandling.h"
 
 #include <iterator>
 using namespace clang;
 using namespace sema;
 
 // Exported for use by Parser.
 SourceRange
 clang::getTemplateParamsRange(TemplateParameterList const * const *Ps,
makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
   ASTTemplateArgsPtr TemplateArgsPtr(TemplateId.getTemplateArgs(),
                                      TemplateId.NumArgs);
   S.translateTemplateArguments(TemplateArgsPtr, TemplateArgs);
   return TemplateArgs;
 }
 
 bool Sema::ActOnTypeConstraint(const CXXScopeSpec &SS,
                                TemplateIdAnnotation *TypeConstr,
-                               TemplateTypeParmDecl *ConstrainedParameter,
+                               NamedDecl *ConstrainedParameter,
                                SourceLocation EllipsisLoc) {
+  assert(isa<TemplateTypeParmDecl>(ConstrainedParameter) ||
+         isa<NonTypeTemplateParmDecl>(ConstrainedParameter));
   return BuildTypeConstraint(SS, TypeConstr, ConstrainedParameter, EllipsisLoc,
                              false);
 }
 
 bool Sema::BuildTypeConstraint(const CXXScopeSpec &SS,
                                TemplateIdAnnotation *TypeConstr,
-                               TemplateTypeParmDecl *ConstrainedParameter,
+                               NamedDecl *ConstrainedParameter,
                                SourceLocation EllipsisLoc,
                                bool AllowUnexpandedPack) {
   TemplateName TN = TypeConstr->Template.get();
   ConceptDecl *CD = cast<ConceptDecl>(TN.getAsTemplateDecl());
 
   // C++2a [temp.param]p4:
   //     [...] The concept designated by a type-constraint shall be a type
   //     concept ([temp.concept]).
if (TypeConstr->LAngleLoc.isValid()) {
 
     if (EllipsisLoc.isInvalid() && !AllowUnexpandedPack) {
       for (TemplateArgumentLoc Arg : TemplateArgs.arguments()) {
         if (DiagnoseUnexpandedParameterPack(Arg, UPPC_TypeConstraint))
           return true;
       }
     }
   }
+
+  if (auto *TypeDecl = dyn_cast<TemplateTypeParmDecl>(ConstrainedParameter))
+  return AttachTypeConstraint(
+      SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc(),
+      ConceptName, CD,
+        TypeConstr->LAngleLoc.isValid() ? &TemplateArgs : nullptr, TypeDecl,
+        EllipsisLoc);
+
+  if (auto *NonTypeDecl =
+          dyn_cast<NonTypeTemplateParmDecl>(ConstrainedParameter))
     return AttachTypeConstraint(
         SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc(),
         ConceptName, CD,
-      TypeConstr->LAngleLoc.isValid() ? &TemplateArgs : nullptr,
-      ConstrainedParameter, EllipsisLoc);
+        TypeConstr->LAngleLoc.isValid() ? &TemplateArgs : nullptr, NonTypeDecl,
+        EllipsisLoc);
+
+  llvm_unreachable("new constrained entity?");
 }
 
 template<typename ArgumentLocAppender>
 static ExprResult formImmediatelyDeclaredConstraint(
     Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo,
     ConceptDecl *NamedConcept, SourceLocation LAngleLoc,
     SourceLocation RAngleLoc, QualType ConstrainedType,
     SourceLocation ParamNameLoc, ArgumentLocAppender Appender,
bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
 
   ConstrainedParameter->setTypeConstraint(NS, NameInfo,
                                           /*FoundDecl=*/NamedConcept,
                                           NamedConcept, ArgsAsWritten,
                                           ImmediatelyDeclaredConstraint.get());
   return false;
 }
 
-bool Sema::AttachTypeConstraint(AutoTypeLoc TL, NonTypeTemplateParmDecl *NTTP,
+bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
+                                DeclarationNameInfo NameInfo,
+                                ConceptDecl *NamedConcept,
+                                const TemplateArgumentListInfo *TemplateArgs,
+                                NonTypeTemplateParmDecl *NTTP,
                                 SourceLocation EllipsisLoc) {
-  if (NTTP->getType() != TL.getType() ||
+  if (AutoTypeLoc TL =
+          NTTP->getTypeSourceInfo()->getTypeLoc().getContainedAutoTypeLoc();
+      NTTP->getType() != TL.getType() ||
       TL.getAutoKeyword() != AutoTypeKeyword::Auto) {
     Diag(NTTP->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
          diag::err_unsupported_placeholder_constraint)
        << NTTP->getTypeSourceInfo()->getTypeLoc().getSourceRange();
     return true;
   }
   // FIXME: Concepts: This should be the type of the placeholder, but this is
   // unclear in the wording right now.
   DeclRefExpr *Ref =
       BuildDeclRefExpr(NTTP, NTTP->getType(), VK_PRValue, NTTP->getLocation());
   if (!Ref)
     return true;
+
+  // C++2a [temp.param]p4:
+  //     [...] If Q is of the form C<A1, ..., An>, then let E' be
+  //     C<T, A1, ..., An>. Otherwise, let E' be C<T>. [...]
+  const ASTTemplateArgumentListInfo *ArgsAsWritten =
+      TemplateArgs ? ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs)
+                   : nullptr;
+
   ExprResult ImmediatelyDeclaredConstraint = formImmediatelyDeclaredConstraint(
-      *this, TL.getNestedNameSpecifierLoc(), TL.getConceptNameInfo(),
-      TL.getNamedConcept(), TL.getLAngleLoc(), TL.getRAngleLoc(),
+      *this, NS, NameInfo, NamedConcept,
+      TemplateArgs ? TemplateArgs->getLAngleLoc() : SourceLocation(),
+      TemplateArgs ? TemplateArgs->getRAngleLoc() : SourceLocation(),
       BuildDecltypeType(Ref), NTTP->getLocation(),
       [&](TemplateArgumentListInfo &ConstraintArgs) {
-        for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
-          ConstraintArgs.addArgument(TL.getArgLoc(I));
+        if (TemplateArgs)
+          for (const auto &ArgLoc : TemplateArgs->arguments())
+            ConstraintArgs.addArgument(ArgLoc);
       },
       EllipsisLoc);
-  if (ImmediatelyDeclaredConstraint.isInvalid() ||
-     !ImmediatelyDeclaredConstraint.isUsable())
+  if (ImmediatelyDeclaredConstraint.isInvalid())
     return true;
 
-  NTTP->setPlaceholderTypeConstraint(ImmediatelyDeclaredConstraint.get());
+  NTTP->setPlaceholderTypeConstraint(NS, NameInfo,
+                                     /*FoundDecl=*/NamedConcept, NamedConcept,
+                                     ArgsAsWritten,
+                                     ImmediatelyDeclaredConstraint.get());
   return false;
 }
 
 /// Check that the type of a non-type template parameter is
 /// well-formed.
 ///
 /// \returns the (possibly-promoted) parameter type if valid;
 /// otherwise, produces a diagnostic and returns a NULL type.
QualType Sema::CheckNonTypeTemplateParameterType(QualType T,
   Diag(Loc, diag::warn_cxx17_compat_template_nontype_parm_type) << T;
   return T.getUnqualifiedType();
 }
 
 NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
                                           unsigned Depth,
                                           unsigned Position,
                                           SourceLocation EqualLoc,
-                                          Expr *Default) {
+                                          Expr *Default,
+                                          bool HasTypeConstraint) {
   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
 
   // Check that we have valid decl-specifiers specified.
   auto CheckValidDeclSpecifiers = [this, &D] {
     // C++ [temp.param]
     // p1
     //   template-parameter:
     //     ...
NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
 
   CheckFunctionOrTemplateParamDeclarator(S, D);
 
   IdentifierInfo *ParamName = D.getIdentifier();
   bool IsParameterPack = D.hasEllipsis();
   NonTypeTemplateParmDecl *Param = NonTypeTemplateParmDecl::Create(
       Context, Context.getTranslationUnitDecl(), D.getBeginLoc(),
       D.getIdentifierLoc(), Depth, Position, ParamName, T, IsParameterPack,
-      TInfo);
+      HasTypeConstraint, TInfo);
   Param->setAccess(AS_public);
 
-  if (AutoTypeLoc TL = TInfo->getTypeLoc().getContainedAutoTypeLoc())
-    if (TL.isConstrained())
-      if (AttachTypeConstraint(TL, Param, D.getEllipsisLoc()))
-        Invalid = true;
-
   if (Invalid)
     Param->setInvalidDecl();
 
   if (Param->isParameterPack())
     if (auto *LSI = getEnclosingLambda())
       LSI->LocalPacks.push_back(Param);
 
   if (ParamName) {
if (isa<DeducedTemplateSpecializationType>(DeducedT)) {
       ParamType =
           DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind, Inits);
       if (ParamType.isNull())
         return ExprError();
     } else {
       TemplateDeductionInfo Info(DeductionArg->getExprLoc(),
                                  Param->getDepth() + 1);
       ParamType = QualType();
+      // In template parameter list, immediately-declared constraint of the auto
+      // type is also an associated constraint, and will be checked along with
+      // the other associated constraints after checking the template argument
+      // list.
+      assert(!TSI->getTypeLoc()
+                  .getType()
+                  ->getContainedAutoType()
+                  ->isConstrained() &&
+             "the auto type should not be constrained when used in template "
+             "parameters");
       TemplateDeductionResult Result =
           DeduceAutoType(TSI->getTypeLoc(), DeductionArg, ParamType, Info,
-                         /*DependentDeduction=*/true,
-                         // We do not check constraints right now because the
-                         // immediately-declared constraint of the auto type is
-                         // also an associated constraint, and will be checked
-                         // along with the other associated constraints after
-                         // checking the template argument list.
-                         /*IgnoreConstraints=*/true);
+                         /*DependentDeduction=*/true);
       if (Result == TDK_AlreadyDiagnosed) {
         if (ParamType.isNull())
           return ExprError();
       } else if (Result != TDK_Success) {
         Diag(Arg->getExprLoc(),
              diag::err_non_type_template_parm_type_deduction_failure)
             << Param->getDeclName() << Param->getType() << Arg->getType()
             << Arg->getSourceRange();
else if (TemplateTemplateParmDecl *OldTTP
     if (!S.TemplateParameterListsAreEqual(
             NewInstFrom, NewTTP->getTemplateParameters(), OldInstFrom,
             OldTTP->getTemplateParameters(), Complain,
             (Kind == Sema::TPL_TemplateMatch
                  ? Sema::TPL_TemplateTemplateParmMatch
                  : Kind),
             TemplateArgLoc))
       return false;
-  } else if (Kind != Sema::TPL_TemplateTemplateArgumentMatch) {
+  }
+
+  if (Kind != Sema::TPL_TemplateTemplateArgumentMatch &&
+      !isa<TemplateTemplateParmDecl>(Old)) {
     const Expr *NewC = nullptr, *OldC = nullptr;
+
+    if (isa<TemplateTypeParmDecl>(New)) {
     if (const auto *TC = cast<TemplateTypeParmDecl>(New)->getTypeConstraint())
       NewC = TC->getImmediatelyDeclaredConstraint();
     if (const auto *TC = cast<TemplateTypeParmDecl>(Old)->getTypeConstraint())
       OldC = TC->getImmediatelyDeclaredConstraint();
+    } else if (isa<NonTypeTemplateParmDecl>(New)) {
+      if (const auto *TC = cast<NonTypeTemplateParmDecl>(New)
+                               ->getPlaceholderTypeConstraint())
+        NewC = TC->getImmediatelyDeclaredConstraint();
+      if (const auto *TC = cast<NonTypeTemplateParmDecl>(Old)
+                               ->getPlaceholderTypeConstraint())
+        OldC = TC->getImmediatelyDeclaredConstraint();
+    } else
+      llvm_unreachable("unexpected template parameter type");
 
     auto Diagnose = [&] {
       S.Diag(NewC ? NewC->getBeginLoc() : New->getBeginLoc(),
            diag::err_template_different_type_constraint);
       S.Diag(OldC ? OldC->getBeginLoc() : Old->getBeginLoc(),
            diag::note_template_prev_declaration) << /*declaration*/0;
     };
 

clang/lib/Sema/SemaTemplateInstantiate.cpp

return AttachTypeConstraint(
       TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
       TC->getNamedConcept(), &InstArgs, Inst,
       Inst->isParameterPack()
           ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                 ->getEllipsisLoc()
           : SourceLocation());
 }
 
+bool Sema::SubstTypeConstraint(
+    NonTypeTemplateParmDecl *Inst, const TypeConstraint *TC,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    SourceLocation EllipsisLoc, bool EvaluateConstraints) {
+  const ASTTemplateArgumentListInfo *TemplArgInfo =
+      TC->getTemplateArgsAsWritten();
+
+  if (!EvaluateConstraints) {
+    Inst->setPlaceholderTypeConstraint(
+        TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
+        TC->getNamedConcept(), TC->getNamedConcept(), TemplArgInfo,
+        TC->getImmediatelyDeclaredConstraint());
+    return false;
+  }
+
+  TemplateArgumentListInfo InstArgs;
+
+  if (TemplArgInfo) {
+    InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
+    InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
+    if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
+                               InstArgs))
+      return true;
+  }
+
+  return AttachTypeConstraint(TC->getNestedNameSpecifierLoc(),
+                              TC->getConceptNameInfo(), TC->getNamedConcept(),
+                              &InstArgs, Inst, EllipsisLoc);
+}
+
 ParmVarDecl *
 Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
                        int indexAdjustment, Optional<unsigned> NumExpansions,
                        bool ExpectParameterPack, bool EvaluateConstraint) {
   TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
   TypeSourceInfo *NewDI = nullptr;
 

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (D->isExpandedParameterPack()) {
     }
   }
 
   NonTypeTemplateParmDecl *Param;
   if (IsExpandedParameterPack)
     Param = NonTypeTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
-        D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
+        D->getPosition(), D->getIdentifier(), T,
+        D->hasPlaceholderTypeConstraint(), DI, ExpandedParameterPackTypes,
         ExpandedParameterPackTypesAsWritten);
   else
     Param = NonTypeTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
-        D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
+        D->getPosition(), D->getIdentifier(), T, D->isParameterPack(),
+        D->hasPlaceholderTypeConstraint(), DI);
 
-  if (AutoTypeLoc AutoLoc = DI->getTypeLoc().getContainedAutoTypeLoc())
-    if (AutoLoc.isConstrained())
-      if (SemaRef.AttachTypeConstraint(
-              AutoLoc, Param,
+  if (auto *TC = D->getPlaceholderTypeConstraint())
+    if (SemaRef.SubstTypeConstraint(Param, TC, TemplateArgs,
                                     IsExpandedParameterPack
-                ? DI->getTypeLoc().getAs<PackExpansionTypeLoc>()
+                                        ? DI->getTypeLoc()
+                                              .getAs<PackExpansionTypeLoc>()
                                               .getEllipsisLoc()
-                : SourceLocation()))
-        Invalid = true;
+                                        : SourceLocation(),
+                                    EvaluateConstraints))
+      return nullptr;
 
   Param->setAccess(AS_public);
   Param->setImplicit(D->isImplicit());
   if (Invalid)
     Param->setInvalidDecl();
 
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     EnterExpressionEvaluationContext ConstantEvaluated(

clang/lib/Serialization/ASTReaderDecl.cpp

if (Record.readInt())
     D->setDefaultArgument(readTypeSourceInfo());
 }
 
 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   VisitDeclaratorDecl(D);
   // TemplateParmPosition.
   D->setDepth(Record.readInt());
   D->setPosition(Record.readInt());
-  if (D->hasPlaceholderTypeConstraint())
-    D->setPlaceholderTypeConstraint(Record.readExpr());
+  if (D->hasPlaceholderTypeConstraint()) {
+    NestedNameSpecifierLoc NNS = Record.readNestedNameSpecifierLoc();
+    DeclarationNameInfo DN = Record.readDeclarationNameInfo();
+    ConceptDecl *NamedConcept = Record.readDeclAs<ConceptDecl>();
+    const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
+    if (Record.readBool())
+      ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
+    Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
+    D->setPlaceholderTypeConstraint(NNS, DN, /*FoundDecl=*/nullptr,
+                                    NamedConcept, ArgsAsWritten,
+                                    ImmediatelyDeclaredConstraint);
+  }
+
   if (D->isExpandedParameterPack()) {
     auto TypesAndInfos =
         D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
       new (&TypesAndInfos[I].first) QualType(Record.readType());
       TypesAndInfos[I].second = readTypeSourceInfo();
     }
   } else {

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
 
   Code = serialization::DECL_TEMPLATE_TYPE_PARM;
 }
 
 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   // For an expanded parameter pack, record the number of expansion types here
   // so that it's easier for deserialization to allocate the right amount of
   // memory.
-  Expr *TypeConstraint = D->getPlaceholderTypeConstraint();
-  Record.push_back(!!TypeConstraint);
+  const TypeConstraint *TC = D->getPlaceholderTypeConstraint();
+  Record.push_back(TC != nullptr);
   if (D->isExpandedParameterPack())
     Record.push_back(D->getNumExpansionTypes());
 
   VisitDeclaratorDecl(D);
   // TemplateParmPosition.
   Record.push_back(D->getDepth());
   Record.push_back(D->getPosition());
-  if (TypeConstraint)
-    Record.AddStmt(TypeConstraint);
+  if (TC) {
+    Record.AddNestedNameSpecifierLoc(TC->getNestedNameSpecifierLoc());
+    Record.AddDeclarationNameInfo(TC->getConceptNameInfo());
+    Record.AddDeclRef(TC->getNamedConcept());
+    Record.push_back(TC->getTemplateArgsAsWritten() != nullptr);
+    if (TC->getTemplateArgsAsWritten())
+      Record.AddASTTemplateArgumentListInfo(TC->getTemplateArgsAsWritten());
+    Record.AddStmt(TC->getImmediatelyDeclaredConstraint());
+  }
 
   if (D->isExpandedParameterPack()) {
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
       Record.AddTypeRef(D->getExpansionType(I));
       Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
     }
 
     Code = serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK;

clang/test/SemaTemplate/instantiate-expanded-type-constraint.cpp

struct T {
     // expected-note@-1{{candidate template ignored: deduced too few arguments}}
     // expected-note@-2{{candidate template ignored: constraints not satisfied}}
 
     template<typename... Us>
     struct S {
         template<either<Ts, Us...>... Vs>
         static void foo(Vs... v);
     };
+
+    template<typename... Us>
+    struct R {
+        template<either<Ts, Us...> auto... Vs>
+        static void foo();
+    };
 };
 
 int main() {
   T<int, bool>::foo(1); // expected-error{{no matching function for call to 'foo'}}
   T<int, bool>::foo(1, 2, 3); // expected-error{{no matching function for call to 'foo'}}
   T<int, bool>::S<char>::foo(1, 'a');
   T<int, bool>::S<char>::foo('a', true);
+  T<int, bool>::R<char>::foo<1, 'a'>();
+  T<int, bool>::R<char>::foo<'a', true>();
 }

clang/tools/libclang/CIndex.cpp

bool CursorVisitor::VisitVarDecl(VarDecl *D) {
 
   if (Expr *Init = D->getInit())
     return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
 
   return false;
 }
 
 bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
+  if (const auto *TC = D->getPlaceholderTypeConstraint()) {
+    if (VisitTypeConstraint(*TC))
+      return true;
+  }
+
   if (VisitDeclaratorDecl(D))
     return true;
 
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     if (Expr *DefArg = D->getDefaultArgument())
       return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));
 
   return false;
for (unsigned I = 0, N = Params->size(); I != N; ++I) {
       NamedDecl *Param = Params->getParam(I);
       if (Param->getIdentifier()) {
         OS << Param->getIdentifier()->getName();
         continue;
       }
 
       // There is no parameter name, which makes this tricky. Try to come up
       // with something useful that isn't too long.
-      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
+      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
         if (const auto *TC = TTP->getTypeConstraint()) {
           TC->getConceptNameInfo().printName(OS, Policy);
           if (TC->hasExplicitTemplateArgs())
             OS << "<...>";
         } else
           OS << (TTP->wasDeclaredWithTypename() ? "typename" : "class");
-      else if (NonTypeTemplateParmDecl *NTTP =
-                   dyn_cast<NonTypeTemplateParmDecl>(Param))
+      } else if (NonTypeTemplateParmDecl *NTTP =
+                     dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+        if (const auto *TC = NTTP->getPlaceholderTypeConstraint()) {
+          TC->getConceptNameInfo().printName(OS, Policy);
+          if (TC->hasExplicitTemplateArgs())
+            OS << "<...>";
+        }
         OS << NTTP->getType().getAsString(Policy);
-      else
+      } else
         OS << "template<...> class";
     }
 
     OS << ">";
     return cxstring::createDup(OS.str());
   }
 
   if (const ClassTemplateSpecializationDecl *ClassSpec =