diff --git a/clang/include/clang/AST/ASTConcept.h b/clang/include/clang/AST/ASTConcept.h
index 00500e214f4ce..ace4de0d62772 100644
--- a/clang/include/clang/AST/ASTConcept.h
+++ b/clang/include/clang/AST/ASTConcept.h
@@ -26,6 +26,7 @@
 namespace clang {
 
 class ConceptDecl;
+class TemplateDecl;
 class Expr;
 class NamedDecl;
 struct PrintingPolicy;
@@ -122,6 +123,7 @@ struct ASTConstraintSatisfaction final :
 ///   template <std::derives_from<Expr> T> void dump();
 ///             ~~~~~~~~~~~~~~~~~~~~~~~ (in TemplateTypeParmDecl)
 class ConceptReference {
+protected:
   // \brief The optional nested name specifier used when naming the concept.
   NestedNameSpecifierLoc NestedNameSpec;
 
@@ -139,7 +141,7 @@ class ConceptReference {
   NamedDecl *FoundDecl;
 
   /// \brief The concept named.
-  ConceptDecl *NamedConcept;
+  TemplateDecl *NamedConcept;
 
   /// \brief The template argument list source info used to specialize the
   /// concept.
@@ -147,7 +149,7 @@ class ConceptReference {
 
   ConceptReference(NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
                    DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl,
-                   ConceptDecl *NamedConcept,
+                   TemplateDecl *NamedConcept,
                    const ASTTemplateArgumentListInfo *ArgsAsWritten)
       : NestedNameSpec(NNS), TemplateKWLoc(TemplateKWLoc),
         ConceptName(ConceptNameInfo), FoundDecl(FoundDecl),
@@ -157,7 +159,7 @@ class ConceptReference {
   static ConceptReference *
   Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
          SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
-         NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
+         NamedDecl *FoundDecl, TemplateDecl *NamedConcept,
          const ASTTemplateArgumentListInfo *ArgsAsWritten);
 
   const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
@@ -196,9 +198,7 @@ class ConceptReference {
     return FoundDecl;
   }
 
-  ConceptDecl *getNamedConcept() const {
-    return NamedConcept;
-  }
+  TemplateDecl *getNamedConcept() const { return NamedConcept; }
 
   const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
     return ArgsAsWritten;
@@ -247,7 +247,7 @@ class TypeConstraint {
 
   // FIXME: Instead of using these concept related functions the callers should
   // directly work with the corresponding ConceptReference.
-  ConceptDecl *getNamedConcept() const { return ConceptRef->getNamedConcept(); }
+  TemplateDecl *getNamedConcept() const { return ConceptRef->getNamedConcept(); }
 
   SourceLocation getConceptNameLoc() const {
     return ConceptRef->getConceptNameLoc();
@@ -278,6 +278,56 @@ class TypeConstraint {
   void print(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const {
     ConceptRef->print(OS, Policy);
   }
+
+};
+
+class PartiallyAppliedConcept : public ConceptReference,
+                                public llvm::FoldingSetNode {
+
+  SourceLocation ConceptKWLoc;
+  PartiallyAppliedConcept(NestedNameSpecifierLoc NNS,
+                          DeclarationNameInfo ConceptNameInfo,
+                          SourceLocation ConceptKWLoc, NamedDecl *FoundDecl,
+                          TemplateDecl *NamedConcept,
+                          const ASTTemplateArgumentListInfo *ArgsAsWritten)
+      : ConceptReference(NNS, /*TemplateKWLoc=*/SourceLocation(),
+                         ConceptNameInfo, FoundDecl, NamedConcept,
+                         ArgsAsWritten),
+        ConceptKWLoc(ConceptKWLoc) {}
+
+public:
+  static PartiallyAppliedConcept *
+  Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
+         DeclarationNameInfo ConceptNameInfo, SourceLocation ConceptKWLoc,
+         NamedDecl *FoundDecl, TemplateDecl *NamedConcept,
+         const TemplateArgumentListInfo &TemplateArgs);
+
+  TemplateArgumentDependence getDependence() const;
+
+  bool isDependent() const {
+    return getDependence() & TemplateArgumentDependence::Dependent;
+  }
+
+  bool isInstantiationDependent() const {
+    return getDependence() & TemplateArgumentDependence::Instantiation;
+  }
+
+  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) const {
+    Profile(ID, C, getNamedConcept(), getTemplateArgsAsWritten());
+  }
+
+  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C,
+                      const TemplateDecl *NamedConcept,
+                      const ASTTemplateArgumentListInfo *ArgsAsWritten);
+
+  SourceLocation getConceptKWLoc() const { return ConceptKWLoc; }
+
+  SourceRange getSourceRange() const {
+    return {ConceptKWLoc, ArgsAsWritten->getRAngleLoc()};
+  }
+
+  friend const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
+                                               PartiallyAppliedConcept &C);
 };
 
 } // clang
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 1984310df0442..272a712fe170c 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -24,6 +24,7 @@
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/TemplateName.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
@@ -96,6 +97,7 @@ class ObjCTypeParamDecl;
 class OMPTraitInfo;
 class ParentMapContext;
 struct ParsedTargetAttr;
+class PartiallyAppliedConcept;
 class Preprocessor;
 class ProfileList;
 class StoredDeclsMap;
@@ -1660,7 +1662,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   QualType
   getAutoTypeInternal(QualType DeducedType, AutoTypeKeyword Keyword,
                       bool IsDependent, bool IsPack = false,
-                      ConceptDecl *TypeConstraintConcept = nullptr,
+                      TemplateDecl *TypeConstraintConcept = nullptr,
                       ArrayRef<TemplateArgument> TypeConstraintArgs = {},
                       bool IsCanon = false) const;
 
@@ -1825,10 +1827,11 @@ class ASTContext : public RefCountedBase<ASTContext> {
                                  UnaryTransformType::UTTKind UKind) const;
 
   /// C++11 deduced auto type.
-  QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
-                       bool IsDependent, bool IsPack = false,
-                       ConceptDecl *TypeConstraintConcept = nullptr,
-                       ArrayRef<TemplateArgument> TypeConstraintArgs ={}) const;
+  QualType
+  getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent,
+              bool IsPack = false,
+              TemplateDecl *TypeConstraintConcept = nullptr,
+              ArrayRef<TemplateArgument> TypeConstraintArgs = {}) const;
 
   /// C++11 deduction pattern for 'auto' type.
   QualType getAutoDeductType() const;
@@ -2334,6 +2337,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
                                                 unsigned Index,
                                                 bool Final) const;
 
+  UniversalTemplateParameterName *
+  getUniversalTemplateParameterName(SourceLocation Loc,
+                                    DeclarationNameInfo Name,
+                                    UniversalTemplateParmDecl *Decl) const;
   /// Represents a TemplateName which had some of its default arguments
   /// deduced. This both represents this default argument deduction as sugar,
   /// and provides the support for it's equivalences through canonicalization.
diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h
index a443a88bab1f2..b0f1109ad1977 100644
--- a/clang/include/clang/AST/ASTNodeTraverser.h
+++ b/clang/include/clang/AST/ASTNodeTraverser.h
@@ -722,6 +722,8 @@ class ASTNodeTraverser
           D->defaultArgumentWasInherited() ? "inherited from" : "previous");
   }
 
+  void VisitUniversalTemplateParmDecl(const UniversalTemplateParmDecl *D) {}
+
   void VisitConceptDecl(const ConceptDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());
     Visit(D->getConstraintExpr());
diff --git a/clang/include/clang/AST/DeclTemplate.h b/clang/include/clang/AST/DeclTemplate.h
index 687715a22e9fd..bdc37eb6224b5 100644
--- a/clang/include/clang/AST/DeclTemplate.h
+++ b/clang/include/clang/AST/DeclTemplate.h
@@ -26,6 +26,7 @@
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TemplateKinds.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerIntPair.h"
@@ -53,6 +54,7 @@ class IdentifierInfo;
 class NonTypeTemplateParmDecl;
 class TemplateDecl;
 class TemplateTemplateParmDecl;
+class UniversalTemplateParmDecl;
 class TemplateTypeParmDecl;
 class ConceptDecl;
 class UnresolvedSetImpl;
@@ -62,7 +64,7 @@ class VarTemplatePartialSpecializationDecl;
 /// Stores a template parameter of any kind.
 using TemplateParameter =
     llvm::PointerUnion<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,
-                       TemplateTemplateParmDecl *>;
+                       TemplateTemplateParmDecl *, UniversalTemplateParmDecl *>;
 
 NamedDecl *getAsNamedDecl(TemplateParameter P);
 
@@ -1600,15 +1602,22 @@ class TemplateTemplateParmDecl final
   /// The number of parameters in an expanded parameter pack.
   unsigned NumExpandedParams = 0;
 
+  TemplateNameKind ParameterKind = TemplateNameKind::TNK_Type_template;
+
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L, unsigned D,
                            unsigned P, bool ParameterPack, IdentifierInfo *Id,
-                           bool Typename, TemplateParameterList *Params)
+                           TemplateNameKind ParameterKind,
+                           bool Typename,
+                           TemplateParameterList *Params)
       : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
         TemplateParmPosition(D, P), Typename(Typename),
-        ParameterPack(ParameterPack), ExpandedParameterPack(false) {}
+        ParameterPack(ParameterPack),
+        ExpandedParameterPack(false), ParameterKind(ParameterKind) {}
 
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L, unsigned D,
-                           unsigned P, IdentifierInfo *Id, bool Typename,
+                           unsigned P, IdentifierInfo *Id,
+                           TemplateNameKind ParameterKind,
+                           bool Typename,
                            TemplateParameterList *Params,
                            ArrayRef<TemplateParameterList *> Expansions);
 
@@ -1619,14 +1628,17 @@ class TemplateTemplateParmDecl final
   friend class ASTDeclWriter;
   friend TrailingObjects;
 
-  static TemplateTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
-                                          SourceLocation L, unsigned D,
-                                          unsigned P, bool ParameterPack,
-                                          IdentifierInfo *Id, bool Typename,
-                                          TemplateParameterList *Params);
   static TemplateTemplateParmDecl *
   Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D,
-         unsigned P, IdentifierInfo *Id, bool Typename,
+         unsigned P, bool ParameterPack, IdentifierInfo *Id,
+         TemplateNameKind ParameterKind, bool Typename,
+         TemplateParameterList *Params);
+
+  static TemplateTemplateParmDecl *
+  Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D,
+         unsigned P, IdentifierInfo *Id,
+         TemplateNameKind ParameterKind,
+         bool Typename,
          TemplateParameterList *Params,
          ArrayRef<TemplateParameterList *> Expansions);
 
@@ -1741,11 +1753,90 @@ class TemplateTemplateParmDecl final
     return SourceRange(getTemplateParameters()->getTemplateLoc(), End);
   }
 
+  TemplateNameKind kind() const {
+      return ParameterKind;
+  }
+
+  bool isTypeConceptTemplateParam() const {
+    return kind() == TemplateNameKind::TNK_Concept_template &&
+           getTemplateParameters()->size() > 0 &&
+           isa<TemplateTypeParmDecl>(getTemplateParameters()->getParam(0));
+  }
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
 };
 
+class UniversalTemplateParmDecl final : public NamedDecl,
+                                        protected TemplateParmPosition {
+
+  /// Whether this universal template parameter is a parameter pack.
+  bool ParameterPack;
+
+  UniversalTemplateParmDecl(DeclContext *DC, SourceLocation L, unsigned D,
+                            unsigned P, bool ParameterPack, IdentifierInfo *Id)
+      : NamedDecl(UniversalTemplateParm, DC, L, Id), TemplateParmPosition(D, P),
+        ParameterPack(ParameterPack) {}
+
+  // UniversalTemplateParmDecl(DeclContext *DC, SourceLocation L, unsigned D,
+  //                          unsigned P, IdentifierInfo *Id,
+  //                          TemplateNameKind ParameterKind,
+  //                          TemplateParameterList *Params,
+  //                          ArrayRef<TemplateParameterList *> Expansions);
+
+  void anchor() override {}
+
+public:
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+
+  static UniversalTemplateParmDecl *Create(const ASTContext &C, DeclContext *DC,
+                                           SourceLocation L, unsigned D,
+                                           unsigned P, bool ParameterPack,
+                                           IdentifierInfo *Id);
+
+  // static TemplateTemplateParmDecl *
+  // Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D,
+  ///       unsigned P, IdentifierInfo *Id, TemplateNameKind ParameterKind,
+  //       TemplateParameterList *Params,
+  //       ArrayRef<TemplateParameterList *> Expansions);
+
+  static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
+                                                      unsigned ID);
+  // static TemplateTemplateParmDecl *CreateDeserialized(ASTContext &C,
+  //                                                     unsigned ID,
+  //                                                     unsigned
+  //                                                     NumExpansions);
+
+  using TemplateParmPosition::getDepth;
+  using TemplateParmPosition::getIndex;
+  using TemplateParmPosition::getPosition;
+  using TemplateParmPosition::setDepth;
+  using TemplateParmPosition::setPosition;
+
+  /// Whether this template template parameter is a template
+  /// parameter pack.
+  ///
+  /// \code
+  /// template<template <class T> ...MetaFunctions> struct Apply;
+  /// \endcode
+  bool isParameterPack() const { return ParameterPack; }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == UniversalTemplateParm; }
+
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, ParameterPack, getASTContext());
+  }
+
+  static void Profile(llvm::FoldingSetNodeID &ID, bool ParameterPack,
+                      const ASTContext &Context) {
+    ID.AddBoolean(ParameterPack);
+  }
+};
+
 /// Represents the builtin template declaration which is used to
 /// implement __make_integer_seq and other builtin templates.  It serves
 /// no real purpose beyond existing as a place to hold template parameters.
@@ -3296,6 +3387,8 @@ inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
     return PD;
   if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
     return PD;
+  if (auto *PD = P.dyn_cast<UniversalTemplateParmDecl *>())
+    return PD;
   return P.get<TemplateTemplateParmDecl *>();
 }
 
@@ -3304,7 +3397,12 @@ inline TemplateDecl *getAsTypeTemplateDecl(Decl *D) {
   return TD && (isa<ClassTemplateDecl>(TD) ||
                 isa<ClassTemplatePartialSpecializationDecl>(TD) ||
                 isa<TypeAliasTemplateDecl>(TD) ||
-                isa<TemplateTemplateParmDecl>(TD))
+                [&]() {
+                  if (TemplateTemplateParmDecl *TTP =
+                          dyn_cast<TemplateTemplateParmDecl>(TD))
+                    return TTP->kind() == TNK_Type_template;
+                  return false;
+                }())
              ? TD
              : nullptr;
 }
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
index 975bcdac5069b..ff49bd9ea09b3 100644
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -38,6 +38,7 @@
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TemplateKinds.h"
 #include "clang/Basic/TypeTraits.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -3132,7 +3133,49 @@ class OverloadExpr : public Expr {
   bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
 
   /// Determines whether this expression had explicit template arguments.
-  bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
+  bool hasExplicitTemplateArgs() const {
+    if (!hasTemplateKWAndArgsInfo())
+      return false;
+    // FIXME corentin: deduced function types can have "hidden" args and no <
+    // investigate that further, but ultimately maybe we want to model concepts
+    // reference with another kind of expression.
+    return (isConceptReference() || isVarDeclReference())
+               ? getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs
+               : getLAngleLoc().isValid();
+  }
+
+  bool isConceptReference() const {
+    return getNumDecls() == 1 && [&]() {
+      if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
+              getTrailingResults()->getDecl()))
+        return TTP->kind() == TNK_Concept_template;
+      if (isa<ConceptDecl>(getTrailingResults()->getDecl()))
+        return true;
+      return false;
+    }();
+  }
+
+  bool isVarDeclReference() const {
+    return getNumDecls() == 1 && [&]() {
+      if (auto *TTP = dyn_cast_or_null<TemplateTemplateParmDecl>(
+              getTrailingResults()->getDecl()))
+        return TTP->kind() == TNK_Var_template;
+      if (isa<VarTemplateDecl>(getTrailingResults()->getDecl()))
+        return true;
+      return false;
+    }();
+  }
+
+  TemplateDecl *getTemplateDecl() const {
+    assert(getNumDecls() == 1);
+    return dyn_cast_or_null<TemplateDecl>(getTrailingResults()->getDecl());
+  }
+
+  TemplateTemplateParmDecl *getTemplateTemplateDecl() const {
+    assert(getNumDecls() == 1);
+    return dyn_cast_or_null<TemplateTemplateParmDecl>(
+        getTrailingResults()->getDecl());
+  }
 
   TemplateArgumentLoc const *getTemplateArgs() const {
     if (!hasExplicitTemplateArgs())
@@ -4535,7 +4578,7 @@ class SubstNonTypeTemplateParmExpr : public Expr {
     return PackIndex - 1;
   }
 
-  NonTypeTemplateParmDecl *getParameter() const;
+  NamedDecl *getParameter() const;
 
   bool isReferenceParameter() const { return AssociatedDeclAndRef.getInt(); }
 
diff --git a/clang/include/clang/AST/ExprConcepts.h b/clang/include/clang/AST/ExprConcepts.h
index 29913fd84c58b..8911b52cf8e32 100644
--- a/clang/include/clang/AST/ExprConcepts.h
+++ b/clang/include/clang/AST/ExprConcepts.h
@@ -84,7 +84,7 @@ class ConceptSpecializationExpr final : public Expr {
 
   ConceptReference *getConceptReference() const { return ConceptRef; }
 
-  ConceptDecl *getNamedConcept() const { return ConceptRef->getNamedConcept(); }
+  ConceptDecl *getNamedConcept() const { return cast<ConceptDecl>(ConceptRef->getNamedConcept()); }
 
   // FIXME: Several of the following functions can be removed. Instead the
   // caller can directly work with the ConceptReference.
@@ -152,6 +152,7 @@ class ConceptSpecializationExpr final : public Expr {
     return ConceptRef->getLocation();
   }
 
+
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
index cd9947f7ab980..c0dd678333662 100644
--- a/clang/include/clang/AST/RecursiveASTVisitor.h
+++ b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -41,6 +41,7 @@
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/Specifiers.h"
@@ -259,6 +260,9 @@ template <typename Derived> class RecursiveASTVisitor {
   /// \returns false if the visitation was terminated early, true otherwise.
   bool TraverseTemplateName(TemplateName Template);
 
+  bool
+  TraverseUniversalTemplateParameterName(UniversalTemplateParameterName *UTPN);
+
   /// Recursively visit a template argument and dispatch to the
   /// appropriate method for the argument type.
   ///
@@ -869,6 +873,12 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
   return true;
 }
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::TraverseUniversalTemplateParameterName(
+    UniversalTemplateParameterName *UTPN) {
+  return true;
+}
+
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
     const TemplateArgument &Arg) {
@@ -893,6 +903,21 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
 
   case TemplateArgument::Pack:
     return getDerived().TraverseTemplateArguments(Arg.pack_elements());
+
+  case TemplateArgument::Concept: {
+    PartiallyAppliedConcept *C = Arg.getAsPartiallyAppliedConcept();
+    TRY_TO(getDerived().TraverseDecl(C->getNamedConcept()));
+    for (const TemplateArgumentLoc &Arg :
+         C->getTemplateArgsAsWritten()->arguments())
+      TRY_TO(TraverseTemplateArgument(Arg.getArgument()));
+    return true;
+  }
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion: {
+    UniversalTemplateParameterName *UTPN =
+        Arg.getAsUniversalTemplateParameterOrPattern();
+    return getDerived().TraverseUniversalTemplateParameterName(UTPN);
+  }
   }
 
   return true;
@@ -929,11 +954,25 @@ bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
     return getDerived().TraverseTemplateName(
         Arg.getAsTemplateOrTemplatePattern());
 
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion:
+    return getDerived().TraverseUniversalTemplateParameterName(
+        Arg.getAsUniversalTemplateParameterOrPattern());
+
   case TemplateArgument::Expression:
     return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
 
   case TemplateArgument::Pack:
     return getDerived().TraverseTemplateArguments(Arg.pack_elements());
+
+  case TemplateArgument::Concept: {
+    PartiallyAppliedConcept *C = Arg.getAsPartiallyAppliedConcept();
+    TRY_TO(getDerived().TraverseDecl(C->getNamedConcept()));
+    for (const TemplateArgumentLoc &Arg :
+         C->getTemplateArgsAsWritten()->arguments())
+      TRY_TO(TraverseTemplateArgument(Arg.getArgument()));
+    return true;
+  }
   }
 
   return true;
@@ -1956,6 +1995,8 @@ DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
+DEF_TRAVERSE_DECL(UniversalTemplateParmDecl, {})
+
 DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
diff --git a/clang/include/clang/AST/TemplateArgumentVisitor.h b/clang/include/clang/AST/TemplateArgumentVisitor.h
index cf0d322015806..2e6d3cf9daf0e 100644
--- a/clang/include/clang/AST/TemplateArgumentVisitor.h
+++ b/clang/include/clang/AST/TemplateArgumentVisitor.h
@@ -42,6 +42,9 @@ class Base {
       DISPATCH(TemplateExpansion);
       DISPATCH(Expression);
       DISPATCH(Pack);
+      DISPATCH(Concept);
+      DISPATCH(Universal);
+      DISPATCH(UniversalExpansion);
     }
     llvm_unreachable("TemplateArgument is not covered in switch!");
   }
@@ -65,6 +68,9 @@ class Base {
   VISIT_METHOD(TemplateExpansion);
   VISIT_METHOD(Expression);
   VISIT_METHOD(Pack);
+  VISIT_METHOD(Concept);
+  VISIT_METHOD(Universal);
+  VISIT_METHOD(UniversalExpansion);
 
   RetTy VisitTemplateArgument(REF(TemplateArgument), ParamTys...) {
     return RetTy();
diff --git a/clang/include/clang/AST/TemplateBase.h b/clang/include/clang/AST/TemplateBase.h
index 0eaa4b0eedb35..f4aded4957fe0 100644
--- a/clang/include/clang/AST/TemplateBase.h
+++ b/clang/include/clang/AST/TemplateBase.h
@@ -14,10 +14,12 @@
 #ifndef LLVM_CLANG_AST_TEMPLATEBASE_H
 #define LLVM_CLANG_AST_TEMPLATEBASE_H
 
+#include "clang/AST/ASTFwd.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/APInt.h"
@@ -56,6 +58,7 @@ class Expr;
 struct PrintingPolicy;
 class TypeSourceInfo;
 class ValueDecl;
+class PartiallyAppliedConcept;
 
 /// Represents a template argument.
 class TemplateArgument {
@@ -104,7 +107,17 @@ class TemplateArgument {
 
     /// The template argument is actually a parameter pack. Arguments are stored
     /// in the Args struct.
-    Pack
+    Pack,
+
+    // A concept with argument
+    Concept,
+
+    /// The template argument refers to a universal template parameter
+    Universal,
+
+    /// The template argument refers to a universal template parameter pack
+    /// expansion
+    UniversalExpansion,
   };
 
 private:
@@ -169,6 +182,20 @@ class TemplateArgument {
     unsigned IsDefaulted : 1;
     uintptr_t V;
   };
+
+  struct ConceptData {
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
+    PartiallyAppliedConcept *C;
+  };
+
+  struct UniversalTpl {
+    unsigned Kind : 31;
+    unsigned IsDefaulted : 1;
+    unsigned NumExpansions;
+    UniversalTemplateParameterName *D;
+  };
+
   union {
     struct DA DeclArg;
     struct I Integer;
@@ -176,6 +203,8 @@ class TemplateArgument {
     struct A Args;
     struct TA TemplateArg;
     struct TV TypeOrValue;
+    struct ConceptData PartialConcept;
+    struct UniversalTpl UniversalArg;
   };
 
   void initFromType(QualType T, bool IsNullPtr, bool IsDefaulted);
@@ -282,6 +311,32 @@ class TemplateArgument {
     this->Args.NumArgs = Args.size();
   }
 
+  explicit TemplateArgument(PartiallyAppliedConcept *C,
+                            bool IsDefaulted = false) {
+    PartialConcept.Kind = Concept;
+    PartialConcept.IsDefaulted = IsDefaulted;
+    PartialConcept.C = C;
+  }
+
+  explicit TemplateArgument(UniversalTemplateParameterName *U,
+                            bool IsDefaulted = false) {
+    UniversalArg.Kind = Universal;
+    UniversalArg.IsDefaulted = IsDefaulted;
+    UniversalArg.NumExpansions = 0;
+    UniversalArg.D = U;
+  }
+
+  explicit TemplateArgument(UniversalTemplateParameterName *U,
+                            std::optional<unsigned> NumExpansions) {
+    UniversalArg.Kind = UniversalExpansion;
+    UniversalArg.IsDefaulted = false;
+    if (NumExpansions)
+      UniversalArg.NumExpansions = *NumExpansions + 1;
+    else
+      UniversalArg.NumExpansions = 0;
+    UniversalArg.D = U;
+  }
+
   static TemplateArgument getEmptyPack() {
     return TemplateArgument(std::nullopt);
   }
@@ -315,6 +370,8 @@ class TemplateArgument {
   /// Determine whether this template argument is a pack expansion.
   bool isPackExpansion() const;
 
+  bool isConceptOrConceptTemplateParameter() const;
+
   /// Retrieve the type for a type template argument.
   QualType getAsType() const {
     assert(getKind() == Type && "Unexpected kind");
@@ -354,6 +411,23 @@ class TemplateArgument {
     return TemplateName::getFromVoidPointer(TemplateArg.Name);
   }
 
+  PartiallyAppliedConcept *getAsPartiallyAppliedConcept() const {
+    assert((getKind() == Concept) && "Unexpected kind");
+    return PartialConcept.C;
+  }
+
+  UniversalTemplateParameterName *getAsUniversalTemplateParameterName() const {
+    assert((getKind() == Universal) && "Unexpected kind");
+    return UniversalArg.D;
+  }
+
+  UniversalTemplateParameterName *
+  getAsUniversalTemplateParameterOrPattern() const {
+    assert((getKind() == Universal || getKind() == UniversalExpansion) &&
+           "Unexpected kind");
+    return UniversalArg.D;
+  }
+
   /// Retrieve the number of expansions that a template template argument
   /// expansion will produce, if known.
   std::optional<unsigned> getNumTemplateExpansions() const;
@@ -480,13 +554,23 @@ struct TemplateArgumentLocInfo {
     SourceLocation EllipsisLoc;
   };
 
-  llvm::PointerUnion<TemplateTemplateArgLocInfo *, Expr *, TypeSourceInfo *>
+  struct UniversalTemplateArgLocInfo {
+    UniversalTemplateParameterName *Name;
+    SourceLocation EllipsisLoc;
+  };
+
+  llvm::PointerUnion<TemplateTemplateArgLocInfo *, Expr *, TypeSourceInfo *,
+                     UniversalTemplateArgLocInfo *>
       Pointer;
 
   TemplateTemplateArgLocInfo *getTemplate() const {
     return Pointer.get<TemplateTemplateArgLocInfo *>();
   }
 
+  UniversalTemplateArgLocInfo *getUniversal() const {
+    return Pointer.get<UniversalTemplateArgLocInfo *>();
+  }
+
 public:
   TemplateArgumentLocInfo() {}
   TemplateArgumentLocInfo(TypeSourceInfo *Declarator) { Pointer = Declarator; }
@@ -498,6 +582,9 @@ struct TemplateArgumentLocInfo {
                           SourceLocation TemplateNameLoc,
                           SourceLocation EllipsisLoc);
 
+  TemplateArgumentLocInfo(ASTContext &Ctx, UniversalTemplateParameterName *,
+                          SourceLocation EllipsisLoc);
+
   TypeSourceInfo *getAsTypeSourceInfo() const {
     return Pointer.get<TypeSourceInfo *>();
   }
@@ -517,6 +604,10 @@ struct TemplateArgumentLocInfo {
   SourceLocation getTemplateEllipsisLoc() const {
     return getTemplate()->EllipsisLoc;
   }
+
+  SourceLocation getUniversalEllipsisLoc() const {
+    return getUniversal()->EllipsisLoc;
+  }
 };
 
 /// Location wrapper for a TemplateArgument.  TemplateArgument is to
@@ -556,13 +647,23 @@ class TemplateArgumentLoc {
       : Argument(Argument),
         LocInfo(Ctx, QualifierLoc, TemplateNameLoc, EllipsisLoc) {
     assert(Argument.getKind() == TemplateArgument::Template ||
-           Argument.getKind() == TemplateArgument::TemplateExpansion);
+           Argument.getKind() == TemplateArgument::TemplateExpansion ||
+           Argument.getKind() == TemplateArgument::Concept);
+  }
+
+  TemplateArgumentLoc(ASTContext &Ctx, const TemplateArgument &Argument,
+                      UniversalTemplateParameterName *Param,
+                      SourceLocation EllipsisLoc = SourceLocation())
+      : Argument(Argument), LocInfo(Ctx, Param, EllipsisLoc) {
+    assert(Argument.getKind() == TemplateArgument::Universal ||
+           Argument.getKind() == TemplateArgument::UniversalExpansion);
   }
 
   /// - Fetches the primary location of the argument.
   SourceLocation getLocation() const {
     if (Argument.getKind() == TemplateArgument::Template ||
-        Argument.getKind() == TemplateArgument::TemplateExpansion)
+        Argument.getKind() == TemplateArgument::TemplateExpansion ||
+        Argument.getKind() == TemplateArgument::Concept)
       return getTemplateNameLoc();
 
     return getSourceRange().getBegin();
@@ -608,14 +709,16 @@ class TemplateArgumentLoc {
 
   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
     if (Argument.getKind() != TemplateArgument::Template &&
-        Argument.getKind() != TemplateArgument::TemplateExpansion)
+        Argument.getKind() != TemplateArgument::TemplateExpansion &&
+        Argument.getKind() != TemplateArgument::Concept)
       return NestedNameSpecifierLoc();
     return LocInfo.getTemplateQualifierLoc();
   }
 
   SourceLocation getTemplateNameLoc() const {
     if (Argument.getKind() != TemplateArgument::Template &&
-        Argument.getKind() != TemplateArgument::TemplateExpansion)
+        Argument.getKind() != TemplateArgument::TemplateExpansion &&
+        Argument.getKind() != TemplateArgument::Concept)
       return SourceLocation();
     return LocInfo.getTemplateNameLoc();
   }
@@ -625,6 +728,12 @@ class TemplateArgumentLoc {
       return SourceLocation();
     return LocInfo.getTemplateEllipsisLoc();
   }
+
+  SourceLocation getUniversalEllipsisLoc() const {
+    if (Argument.getKind() != TemplateArgument::UniversalExpansion)
+      return SourceLocation();
+    return LocInfo.getUniversalEllipsisLoc();
+  }
 };
 
 /// A convenient class for passing around template argument
diff --git a/clang/include/clang/AST/TextNodeDumper.h b/clang/include/clang/AST/TextNodeDumper.h
index 57100e7ede171..110b4df9b46c5 100644
--- a/clang/include/clang/AST/TextNodeDumper.h
+++ b/clang/include/clang/AST/TextNodeDumper.h
@@ -252,6 +252,10 @@ class TextNodeDumper
   void VisitTemplateTemplateArgument(const TemplateArgument &TA);
   void VisitTemplateExpansionTemplateArgument(const TemplateArgument &TA);
   void VisitExpressionTemplateArgument(const TemplateArgument &TA);
+  void VisitConceptTemplateArgument(const TemplateArgument &TA);
+  void VisitUniversalTemplateArgument(const TemplateArgument &TA);
+  void VisitUniversalExpansionTemplateArgument(const TemplateArgument &TA);
+
   void VisitPackTemplateArgument(const TemplateArgument &TA);
 
   void VisitIfStmt(const IfStmt *Node);
diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
index dc87b84153e74..346034a1b5ae5 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -6445,10 +6445,10 @@ class DeducedType : public Type {
 class AutoType : public DeducedType, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
-  ConceptDecl *TypeConstraintConcept;
+  TemplateDecl *TypeConstraintConcept;
 
   AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
-           TypeDependence ExtraDependence, QualType Canon, ConceptDecl *CD,
+           TypeDependence ExtraDependence, QualType Canon, TemplateDecl *CD,
            ArrayRef<TemplateArgument> TypeConstraintArgs);
 
 public:
@@ -6457,7 +6457,7 @@ class AutoType : public DeducedType, public llvm::FoldingSetNode {
             AutoTypeBits.NumArgs};
   }
 
-  ConceptDecl *getTypeConstraintConcept() const {
+  TemplateDecl *getTypeConstraintConcept() const {
     return TypeConstraintConcept;
   }
 
@@ -6480,7 +6480,7 @@ class AutoType : public DeducedType, public llvm::FoldingSetNode {
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context);
   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                       QualType Deduced, AutoTypeKeyword Keyword,
-                      bool IsDependent, ConceptDecl *CD,
+                      bool IsDependent, TemplateDecl *CD,
                       ArrayRef<TemplateArgument> Arguments);
 
   static bool classof(const Type *T) {
diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h
index 62ca52e508ba2..f579d4ec16cd5 100644
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -2259,7 +2259,7 @@ class AutoTypeLoc
     return nullptr;
   }
 
-  ConceptDecl *getNamedConcept() const {
+  TemplateDecl *getNamedConcept() const {
     if (const auto *CR = getConceptReference())
       return CR->getNamedConcept();
     return nullptr;
diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td
index bb7bfa8cd0b76..74d69045aa2f5 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -506,9 +506,9 @@ let Class = AutoType in {
   def : Property<"keyword", AutoTypeKeyword> {
     let Read = [{ node->getKeyword() }];
   }
-  def : Property<"typeConstraintConcept", Optional<ConceptDeclRef>> {
+  def : Property<"typeConstraintConcept", Optional<TemplateDeclRef>> {
     let Read = [{ makeOptionalFromPointer(
-        const_cast<const ConceptDecl*>(node->getTypeConstraintConcept())) }];
+        const_cast<const TemplateDecl*>(node->getTypeConstraintConcept())) }];
   }
   def : Property<"typeConstraintArguments", Array<TemplateArgument>> {
     let Read = [{ node->getTypeConstraintArguments() }];
diff --git a/clang/include/clang/AST/UniversalTemplateParameterName.h b/clang/include/clang/AST/UniversalTemplateParameterName.h
new file mode 100644
index 0000000000000..f72ab8cfca067
--- /dev/null
+++ b/clang/include/clang/AST/UniversalTemplateParameterName.h
@@ -0,0 +1,63 @@
+//===- TemplateName.h - C++ Template Name Representation --------*- C++ -*-===//
+//
+// 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 defines the TemplateName interface and subclasses.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_AST_UNIVERSALTEMPLATEPARAMETERNAME_H
+#define LLVM_CLANG_AST_UNIVERSALTEMPLATEPARAMETERNAME_H
+
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/Basic/SourceLocation.h"
+
+namespace clang {
+
+class UniversalTemplateParmDecl;
+
+class UniversalTemplateParameterName {
+
+  SourceLocation Loc;
+  DeclarationNameInfo Name;
+  UniversalTemplateParmDecl *Param;
+
+public:
+  UniversalTemplateParameterName(SourceLocation Loc, DeclarationNameInfo Name,
+                                 UniversalTemplateParmDecl *Param);
+
+  SourceLocation getLocation() const { return Loc; }
+
+  UniversalTemplateParmDecl *getDecl() const { return Param; }
+
+  DeclarationNameInfo getNameInfo() const { return Name; }
+
+  bool containsUnexpandedParameterPack() const;
+
+  void Profile(const ASTContext &Context, llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, Name, Param, Context);
+  }
+
+  static void Profile(llvm::FoldingSetNodeID &ID, DeclarationNameInfo Name,
+                      const UniversalTemplateParmDecl *Decl,
+                      const ASTContext &Context);
+
+  void print(raw_ostream &OS, const PrintingPolicy &Policy) const;
+
+  void dump(raw_ostream &OS) const;
+  void dump() const;
+};
+
+/// Insertion operator for diagnostics.  This allows sending TemplateName's
+/// into a diagnostic with <<.
+const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
+                                      UniversalTemplateParameterName N);
+
+} // namespace clang
+
+#endif // LLVM_CLANG_AST_UNIVERSALTEMPLATEPARAMETERNAME_H
diff --git a/clang/include/clang/Basic/DeclNodes.td b/clang/include/clang/Basic/DeclNodes.td
index 48396e85c5ada..971a75395395f 100644
--- a/clang/include/clang/Basic/DeclNodes.td
+++ b/clang/include/clang/Basic/DeclNodes.td
@@ -70,6 +70,7 @@ def Named : DeclNode<Decl, "named declarations", 1>;
       def VarTemplate : DeclNode<RedeclarableTemplate>;
       def TypeAliasTemplate : DeclNode<RedeclarableTemplate>;
     def TemplateTemplateParm : DeclNode<Template>;
+    def UniversalTemplateParm : DeclNode<Named>;
     def BuiltinTemplate : DeclNode<Template>;
     def Concept : DeclNode<Template>;
   def BaseUsing : DeclNode<Named, "", 1>;
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index e4e04bff8b512..430184c859d58 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5247,7 +5247,7 @@ def err_template_arg_must_be_expr : Error<
 def err_template_arg_nontype_ambig : Error<
   "template argument for non-type template parameter is treated as function type %0">;
 def err_template_arg_must_be_template : Error<
-  "template argument for template template parameter must be a class template%select{| or type alias template}0">;
+  "template argument for template template parameter must be a %select{class template%select{| or type alias template}1|variable template|concept}0">;
 def ext_template_arg_local_type : ExtWarn<
   "template argument uses local type %0">, InGroup<LocalTypeTemplateArgs>;
 def ext_template_arg_unnamed_type : ExtWarn<
@@ -5263,10 +5263,18 @@ def note_template_unnamed_type_here : Note<
 def err_template_arg_overload_type : Error<
   "template argument is the type of an unresolved overloaded function">;
 def err_template_arg_not_valid_template : Error<
-  "template argument does not refer to a class or alias template, or template "
+  "template argument does not refer to a %select{class or alias template|variable template|concept}0, or template "
   "template parameter">;
-def note_template_arg_refers_here_func : Note<
-  "template argument refers to function template %0, here">;
+def err_partial_concept_valid_template : Error<
+  "name of template argument does not refer to concept, or concept "
+  "template parameter">;
+def err_partial_concept_param_must_have_one_arg : Error<
+  "the corresponding template parameter of a partially applied concept must have exactly one argument">;
+def note_concept_template_parameter_declared_here : Error<
+  "concept template parameter declared here">;
+
+def note_template_arg_refers_to_template_here : Note<
+  "template argument refers to a %select{function template|class template|variable template|concept}0 %1, here">;
 def err_template_arg_template_params_mismatch : Error<
   "template template argument has different template parameters than its "
   "corresponding template template parameter">;
@@ -7663,6 +7671,7 @@ def warn_format_nonliteral : Warning<
 def err_unexpected_interface : Error<
   "unexpected interface name %0: expected expression">;
 def err_ref_non_value : Error<"%0 does not refer to a value">;
+def err_ref_utp : Error<"%0 refers to a universal template parameter outside of a template argument list">;
 def err_ref_vm_type : Error<
   "cannot refer to declaration with a variably modified type inside block">;
 def err_ref_flexarray_type : Error<
diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def
index c5c3838407cf4..8441e03ef2bcb 100644
--- a/clang/include/clang/Basic/TokenKinds.def
+++ b/clang/include/clang/Basic/TokenKinds.def
@@ -860,6 +860,7 @@ ANNOTATION(template_id)  // annotation for a C++ template-id that names a
                          // might not have explicit template arguments),
                          // e.g. "C", "C<int>".
 ANNOTATION(non_type)     // annotation for a single non-type declaration
+ANNOTATION(universal)     // annotation for a universal template parameter
 ANNOTATION(non_type_undeclared) // annotation for an undeclared identifier that
                                 // was assumed to be an ADL-only function name
 ANNOTATION(non_type_dependent)  // annotation for an assumed non-type member of
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index eb8a851da7e04..4bc36c30d94ea 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -14,6 +14,7 @@
 #define LLVM_CLANG_PARSE_PARSER_H
 
 #include "clang/Basic/OpenACCKinds.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/OperatorPrecedence.h"
 #include "clang/Lex/CodeCompletionHandler.h"
 #include "clang/Lex/Preprocessor.h"
@@ -169,6 +170,9 @@ class Parser : public CodeCompletionHandler {
   mutable IdentifierInfo *Ident_import;
   mutable IdentifierInfo *Ident_module;
 
+  // C++2c contextual keywords
+  mutable IdentifierInfo *Ident_universal;
+
   // C++ type trait keywords that can be reverted to identifiers and still be
   // used as type traits.
   llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;
@@ -512,6 +516,8 @@ class Parser : public CodeCompletionHandler {
   // different actual classes based on the actions in place.
   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
   typedef OpaquePtr<TemplateName> TemplateTy;
+  typedef OpaquePtr<UniversalTemplateParameterName *>
+      UniversalTemplateParamNameTy;
 
   typedef SmallVector<TemplateParameterList *, 4> TemplateParameterLists;
 
@@ -3820,9 +3826,11 @@ class Parser : public CodeCompletionHandler {
   bool ParseTemplateParameterList(unsigned Depth,
                                   SmallVectorImpl<NamedDecl*> &TemplateParams);
   TPResult isStartOfTemplateTypeParameter();
+  bool isUniversalTemplateParameterIntroducer();
   NamedDecl *ParseTemplateParameter(unsigned Depth, unsigned Position);
   NamedDecl *ParseTypeParameter(unsigned Depth, unsigned Position);
   NamedDecl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
+  NamedDecl *ParseUniversalTemplateParameter(unsigned Depth, unsigned Position);
   NamedDecl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
   bool isTypeConstraintAnnotation();
   bool TryAnnotateTypeConstraint();
@@ -3857,7 +3865,9 @@ class Parser : public CodeCompletionHandler {
                                 bool IsClassName = false);
   bool ParseTemplateArgumentList(TemplateArgList &TemplateArgs,
                                  TemplateTy Template, SourceLocation OpenLoc);
+  ParsedTemplateArgument ParsePartiallyAppliedConceptTemplateArgument();
   ParsedTemplateArgument ParseTemplateTemplateArgument();
+  ParsedTemplateArgument ParseUniversalTemplateParamNameArgument();
   ParsedTemplateArgument ParseTemplateArgument();
   DeclGroupPtrTy ParseExplicitInstantiation(DeclaratorContext Context,
                                             SourceLocation ExternLoc,
diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h
index 06243f2624876..e1495b9731c2d 100644
--- a/clang/include/clang/Sema/DeclSpec.h
+++ b/clang/include/clang/Sema/DeclSpec.h
@@ -2899,6 +2899,7 @@ struct InventedTemplateParameterInfo {
   SmallVector<NamedDecl*, 4> TemplateParams;
 };
 
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_SEMA_DECLSPEC_H
diff --git a/clang/include/clang/Sema/Initialization.h b/clang/include/clang/Sema/Initialization.h
index 0455e1fa5016b..48b497a7f406b 100644
--- a/clang/include/clang/Sema/Initialization.h
+++ b/clang/include/clang/Sema/Initialization.h
@@ -160,7 +160,7 @@ class alignas(8) InitializedEntity {
 
   struct VD {
     /// The VarDecl, FieldDecl, or BindingDecl being initialized.
-    ValueDecl *VariableOrMember;
+    NamedDecl *VariableOrMember;
 
     /// When Kind == EK_Member, whether this is an implicit member
     /// initialization in a copy or move constructor. These can perform array
@@ -291,8 +291,8 @@ class alignas(8) InitializedEntity {
   }
 
   /// Create the initialization entity for a template parameter.
-  static InitializedEntity
-  InitializeTemplateParameter(QualType T, NonTypeTemplateParmDecl *Param) {
+  static InitializedEntity InitializeTemplateParameter(QualType T,
+                                                       NamedDecl *Param) {
     InitializedEntity Entity;
     Entity.Kind = EK_TemplateParameter;
     Entity.Type = T;
diff --git a/clang/include/clang/Sema/Ownership.h b/clang/include/clang/Sema/Ownership.h
index 0752f5de7e334..12ee8c4024941 100644
--- a/clang/include/clang/Sema/Ownership.h
+++ b/clang/include/clang/Sema/Ownership.h
@@ -13,6 +13,7 @@
 #ifndef LLVM_CLANG_SEMA_OWNERSHIP_H
 #define LLVM_CLANG_SEMA_OWNERSHIP_H
 
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -36,6 +37,7 @@ class ParsedTemplateArgument;
 class QualType;
 class Stmt;
 class TemplateName;
+class UniversalTemplateParameterName;
 class TemplateParameterList;
 
   /// Wrapper for void* pointer.
@@ -254,6 +256,8 @@ using MemInitResult = ActionResult<CXXCtorInitializer *>;
 using DeclResult = ActionResult<Decl *>;
 using ParsedTemplateTy = OpaquePtr<TemplateName>;
 using UnionParsedTemplateTy = UnionOpaquePtr<TemplateName>;
+using UniversalTemplateParamNameTy =
+    OpaquePtr<UniversalTemplateParameterName *>;
 
 using MultiExprArg = MutableArrayRef<Expr *>;
 using MultiStmtArg = MutableArrayRef<Stmt *>;
diff --git a/clang/include/clang/Sema/ParsedTemplate.h b/clang/include/clang/Sema/ParsedTemplate.h
index ac4dbbf294caf..80cd101b3db1d 100644
--- a/clang/include/clang/Sema/ParsedTemplate.h
+++ b/clang/include/clang/Sema/ParsedTemplate.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_CLANG_SEMA_PARSEDTEMPLATE_H
 #define LLVM_CLANG_SEMA_PARSEDTEMPLATE_H
 
+#include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TemplateKinds.h"
@@ -25,114 +26,142 @@
 #include <new>
 
 namespace clang {
-  /// Represents the parsed form of a C++ template argument.
-  class ParsedTemplateArgument {
-  public:
-    /// Describes the kind of template argument that was parsed.
-    enum KindType {
-      /// A template type parameter, stored as a type.
-      Type,
-      /// A non-type template parameter, stored as an expression.
-      NonType,
-      /// A template template argument, stored as a template name.
-      Template
-    };
-
-    /// Build an empty template argument.
-    ///
-    /// This template argument is invalid.
-    ParsedTemplateArgument() : Kind(Type), Arg(nullptr) { }
-
-    /// Create a template type argument or non-type template argument.
-    ///
-    /// \param Arg the template type argument or non-type template argument.
-    /// \param Loc the location of the type.
-    ParsedTemplateArgument(KindType Kind, void *Arg, SourceLocation Loc)
-      : Kind(Kind), Arg(Arg), Loc(Loc) { }
-
-    /// Create a template template argument.
-    ///
-    /// \param SS the C++ scope specifier that precedes the template name, if
-    /// any.
-    ///
-    /// \param Template the template to which this template template
-    /// argument refers.
-    ///
-    /// \param TemplateLoc the location of the template name.
-    ParsedTemplateArgument(const CXXScopeSpec &SS,
-                           ParsedTemplateTy Template,
-                           SourceLocation TemplateLoc)
-      : Kind(ParsedTemplateArgument::Template),
-        Arg(Template.getAsOpaquePtr()), SS(SS), Loc(TemplateLoc) {}
-
-    /// Determine whether the given template argument is invalid.
-    bool isInvalid() const { return Arg == nullptr; }
-
-    /// Determine what kind of template argument we have.
-    KindType getKind() const { return Kind; }
-
-    /// Retrieve the template type argument's type.
-    ParsedType getAsType() const {
-      assert(Kind == Type && "Not a template type argument");
-      return ParsedType::getFromOpaquePtr(Arg);
-    }
-
-    /// Retrieve the non-type template argument's expression.
-    Expr *getAsExpr() const {
-      assert(Kind == NonType && "Not a non-type template argument");
-      return static_cast<Expr*>(Arg);
-    }
-
-    /// Retrieve the template template argument's template name.
-    ParsedTemplateTy getAsTemplate() const {
-      assert(Kind == Template && "Not a template template argument");
-      return ParsedTemplateTy::getFromOpaquePtr(Arg);
-    }
-
-    /// Retrieve the location of the template argument.
-    SourceLocation getLocation() const { return Loc; }
+class PartiallyAppliedConcept;
+
+/// Represents the parsed form of a C++ template argument.
+class ParsedTemplateArgument {
+public:
+  /// Describes the kind of template argument that was parsed.
+  enum KindType {
+    /// A template type parameter, stored as a type.
+    Type,
+    /// A non-type template parameter, stored as an expression.
+    NonType,
+    /// A template template argument, stored as a template name.
+    Template,
+    /// A partially applied concept
+    PartiallyAppliedConcept,
+    /// The name of a Universal Template Parameter
+    Universal
+  };
 
-    /// Retrieve the nested-name-specifier that precedes the template
-    /// name in a template template argument.
-    const CXXScopeSpec &getScopeSpec() const {
-      assert(Kind == Template &&
-             "Only template template arguments can have a scope specifier");
-      return SS;
-    }
+  /// Build an empty template argument.
+  ///
+  /// This template argument is invalid.
+  ParsedTemplateArgument() : Kind(Type), Arg(nullptr) {}
 
-    /// Retrieve the location of the ellipsis that makes a template
-    /// template argument into a pack expansion.
-    SourceLocation getEllipsisLoc() const {
-      assert(Kind == Template &&
-             "Only template template arguments can have an ellipsis");
-      return EllipsisLoc;
-    }
+  /// Create a template type argument or non-type template argument.
+  ///
+  /// \param Arg the template type argument or non-type template argument.
+  /// \param Loc the location of the type.
+  ParsedTemplateArgument(KindType Kind, void *Arg, SourceLocation Loc)
+      : Kind(Kind), Arg(Arg), Loc(Loc) {}
 
-    /// Retrieve a pack expansion of the given template template
-    /// argument.
-    ///
-    /// \param EllipsisLoc The location of the ellipsis.
-    ParsedTemplateArgument getTemplatePackExpansion(
-                                              SourceLocation EllipsisLoc) const;
+  /// Create a template template argument.
+  ///
+  /// \param SS the C++ scope specifier that precedes the template name, if
+  /// any.
+  ///
+  /// \param Template the template to which this template template
+  /// argument refers.
+  ///
+  /// \param TemplateLoc the location of the template name.
+  ParsedTemplateArgument(const CXXScopeSpec &SS, ParsedTemplateTy Template,
+                         SourceLocation TemplateLoc)
+      : Kind(ParsedTemplateArgument::Template), Arg(Template.getAsOpaquePtr()),
+        SS(SS), Loc(TemplateLoc) {}
+
+  ParsedTemplateArgument(class PartiallyAppliedConcept *Concept,
+                         SourceLocation TemplateLoc)
+      : Kind(ParsedTemplateArgument::PartiallyAppliedConcept), Arg(Concept),
+        Loc(TemplateLoc) {}
+
+  ParsedTemplateArgument(UniversalTemplateParamNameTy ParamName,
+                         SourceLocation Loc)
+      : Kind(ParsedTemplateArgument::Universal),
+        Arg(ParamName.getAsOpaquePtr()), Loc(Loc) {}
+
+  /// Determine whether the given template argument is invalid.
+  bool isInvalid() const { return Arg == nullptr; }
+
+  /// Determine what kind of template argument we have.
+  KindType getKind() const { return Kind; }
+
+  /// Retrieve the template type argument's type.
+  ParsedType getAsType() const {
+    assert(Kind == Type && "Not a template type argument");
+    return ParsedType::getFromOpaquePtr(Arg);
+  }
+
+  /// Retrieve the non-type template argument's expression.
+  Expr *getAsExpr() const {
+    assert(Kind == NonType && "Not a non-type template argument");
+    return static_cast<Expr *>(Arg);
+  }
+
+  /// Retrieve the template template argument's template name.
+  ParsedTemplateTy getAsTemplate() const {
+    assert(Kind == Template && "Not a template template argument");
+    return ParsedTemplateTy::getFromOpaquePtr(Arg);
+  }
+
+  class PartiallyAppliedConcept *getAsConcept() const {
+    assert(Kind == PartiallyAppliedConcept && "Not a concept argument");
+    return reinterpret_cast<class PartiallyAppliedConcept *>(Arg);
+  }
+
+  UniversalTemplateParamNameTy getAsUniversalTemplateParamName() const {
+    assert(Kind == Universal &&
+           "Not a reference to a universal template parameter");
+    return UniversalTemplateParamNameTy::getFromOpaquePtr(Arg);
+  }
+
+  /// Retrieve the location of the template argument.
+  SourceLocation getLocation() const { return Loc; }
+
+  /// Retrieve the nested-name-specifier that precedes the template
+  /// name in a template template argument.
+  const CXXScopeSpec &getScopeSpec() const {
+    assert((Kind == Template || Kind == PartiallyAppliedConcept) &&
+           "Only template template arguments can have a scope specifier");
+    return SS;
+  }
+
+  /// Retrieve the location of the ellipsis that makes a template
+  /// template argument into a pack expansion.
+  SourceLocation getEllipsisLoc() const {
+    assert(
+        (Kind == Template || Kind == Universal) &&
+        "Only template and universal template arguments can have an ellipsis");
+    return EllipsisLoc;
+  }
+
+  /// Retrieve a pack expansion of the given template template
+  /// argument.
+  ///
+  /// \param EllipsisLoc The location of the ellipsis.
+  ParsedTemplateArgument
+  getTemplatePackExpansion(SourceLocation EllipsisLoc) const;
 
-  private:
-    KindType Kind;
+private:
+  KindType Kind;
 
-    /// The actual template argument representation, which may be
-    /// an \c Sema::TypeTy* (for a type), an Expr* (for an
-    /// expression), or an Sema::TemplateTy (for a template).
-    void *Arg;
+  /// The actual template argument representation, which may be
+  /// an \c Sema::TypeTy* (for a type), an Expr* (for an
+  /// expression), or an Sema::TemplateTy (for a template).
+  void *Arg;
 
-    /// The nested-name-specifier that can accompany a template template
-    /// argument.
-    CXXScopeSpec SS;
+  /// The nested-name-specifier that can accompany a template template
+  /// argument.
+  CXXScopeSpec SS;
 
-    /// the location of the template argument.
-    SourceLocation Loc;
+  /// the location of the template argument.
+  SourceLocation Loc;
 
-    /// The ellipsis location that can accompany a template template
-    /// argument (turning it into a template template argument expansion).
-    SourceLocation EllipsisLoc;
+  /// The ellipsis location that can accompany a template/universal template
+  /// argument (turning it into a template/universal template argument
+  /// expansion).
+  SourceLocation EllipsisLoc;
   };
 
   /// Information about a template-id annotation
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index e1c3a99cfa167..15910e424ad61 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -32,6 +32,9 @@
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/TypeOrdering.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
+#include "clang/Basic/BitmaskEnum.h"
 #include "clang/Basic/AttrSubjectMatchRules.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CapturedStmt.h"
@@ -144,6 +147,7 @@ class MangleNumberingContext;
 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
 class ModuleLoader;
 class MultiLevelTemplateArgumentList;
+struct CachedNormalizedConstraint;
 struct NormalizedConstraint;
 class ObjCInterfaceDecl;
 class ObjCMethodDecl;
@@ -970,6 +974,9 @@ class Sema final : public SemaBase {
 
   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
   typedef OpaquePtr<TemplateName> TemplateTy;
+  typedef OpaquePtr<PartiallyAppliedConcept> ConceptTy;
+  typedef OpaquePtr<UniversalTemplateParameterName *>
+      UniversalTemplateParamNameTy;
   typedef OpaquePtr<QualType> TypeTy;
 
   OpenCLOptions OpenCLFeatures;
@@ -3245,6 +3252,8 @@ class Sema final : public SemaBase {
     NC_UndeclaredTemplate,
     /// The name was classified as a concept name.
     NC_Concept,
+    /// The name was classified as the name of a universal template parameter
+    NC_UniversalTemplateParam,
   };
 
   class NameClassification {
@@ -3252,6 +3261,7 @@ class Sema final : public SemaBase {
     union {
       ExprResult Expr;
       NamedDecl *NonTypeDecl;
+      UniversalTemplateParmDecl *UniversalParamDecl;
       TemplateName Template;
       ParsedType Type;
     };
@@ -3313,6 +3323,13 @@ class Sema final : public SemaBase {
       return Result;
     }
 
+    static NameClassification
+    Universal(UniversalTemplateParmDecl *UniversalParamDecl) {
+      NameClassification Result(NC_UniversalTemplateParam);
+      Result.UniversalParamDecl = UniversalParamDecl;
+      return Result;
+    }
+
     static NameClassification UndeclaredTemplate(TemplateName Name) {
       NameClassification Result(NC_UndeclaredTemplate);
       Result.Template = Name;
@@ -3331,6 +3348,11 @@ class Sema final : public SemaBase {
       return Type;
     }
 
+    NamedDecl *getUniversalTemplateDecl() const {
+      assert(Kind == NC_UniversalTemplateParam);
+      return UniversalParamDecl;
+    }
+
     NamedDecl *getNonTypeDecl() const {
       assert(Kind == NC_NonType);
       return NonTypeDecl;
@@ -8912,7 +8934,6 @@ class Sema final : public SemaBase {
   getCurrentMangleNumberContext(const DeclContext *DC);
 
   ///@}
-
   //
   //
   // -------------------------------------------------------------------------
@@ -11249,7 +11270,7 @@ class Sema final : public SemaBase {
   /// of arguments for the named concept).
   bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
                             DeclarationNameInfo NameInfo,
-                            ConceptDecl *NamedConcept, NamedDecl *FoundDecl,
+                            TemplateDecl *NamedConcept,  NamedDecl *FoundDecl,
                             const TemplateArgumentListInfo *TemplateArgs,
                             TemplateTypeParmDecl *ConstrainedParameter,
                             SourceLocation EllipsisLoc);
@@ -11274,26 +11295,41 @@ class Sema final : public SemaBase {
   QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
 
   NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
-                                           unsigned Depth, unsigned Position,
-                                           SourceLocation EqualLoc,
-                                           Expr *DefaultArg);
+                                      unsigned Depth,
+                                      unsigned Position,
+                                      SourceLocation EqualLoc,
+                                      Expr *DefaultArg);
 
   /// ActOnTemplateTemplateParameter - Called when a C++ template template
   /// parameter (e.g. T in template <template \<typename> class T> class array)
   /// has been parsed. S is the current scope.
   NamedDecl *ActOnTemplateTemplateParameter(
-      Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params,
-      bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *ParamName,
-      SourceLocation ParamNameLoc, unsigned Depth, unsigned Position,
-      SourceLocation EqualLoc, ParsedTemplateArgument DefaultArg);
+      Scope *S, SourceLocation TmpLoc,
+      TemplateNameKind Kind,
+      bool TypenameKeyword,
+      TemplateParameterList *Params, SourceLocation EllipsisLoc,
+      IdentifierInfo *ParamName, SourceLocation ParamNameLoc, unsigned Depth,
+      unsigned Position, SourceLocation EqualLoc,
+      ParsedTemplateArgument DefaultArg);
+
+  NamedDecl *ActOnUniversalTemplateParameter(Scope *S,
+                                             SourceLocation IntroducerLoc,
+                                             SourceLocation EllipsisLoc,
+                                             IdentifierInfo *ParamName,
+                                             SourceLocation ParamNameLoc,
+                                             unsigned Depth, unsigned Position);
 
   /// ActOnTemplateParameterList - Builds a TemplateParameterList, optionally
   /// constrained by RequiresClause, that contains the template parameters in
   /// Params.
-  TemplateParameterList *ActOnTemplateParameterList(
-      unsigned Depth, SourceLocation ExportLoc, SourceLocation TemplateLoc,
-      SourceLocation LAngleLoc, ArrayRef<NamedDecl *> Params,
-      SourceLocation RAngleLoc, Expr *RequiresClause);
+  TemplateParameterList *
+  ActOnTemplateParameterList(unsigned Depth,
+                             SourceLocation ExportLoc,
+                             SourceLocation TemplateLoc,
+                             SourceLocation LAngleLoc,
+                             ArrayRef<NamedDecl *> Params,
+                             SourceLocation RAngleLoc,
+                             Expr *RequiresClause);
 
   /// The context in which we are checking a template parameter list.
   enum TemplateParamListContext {
@@ -11435,7 +11471,7 @@ class Sema final : public SemaBase {
   /// Get the specialization of the given variable template corresponding to
   /// the specified argument list, or a null-but-valid result if the arguments
   /// are dependent.
-  DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
+  DeclResult CheckVarTemplateId(VarTemplateDecl  *Template,
                                 SourceLocation TemplateLoc,
                                 SourceLocation TemplateNameLoc,
                                 const TemplateArgumentListInfo &TemplateArgs);
@@ -11450,7 +11486,14 @@ class Sema final : public SemaBase {
                                 const TemplateArgumentListInfo *TemplateArgs);
 
   ExprResult
-  CheckConceptTemplateId(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
+  CheckVarOrConceptTemplateTemplateId(const CXXScopeSpec &SS,
+                           const DeclarationNameInfo &NameInfo,
+                           TemplateTemplateParmDecl *Template, SourceLocation TemplateLoc,
+                           const TemplateArgumentListInfo *TemplateArgs);
+
+  ExprResult
+  CheckConceptTemplateId(const CXXScopeSpec &SS,
+                         SourceLocation TemplateKWLoc,
                          const DeclarationNameInfo &ConceptNameInfo,
                          NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
                          const TemplateArgumentListInfo *TemplateArgs);
@@ -11494,6 +11537,20 @@ class Sema final : public SemaBase {
                                      bool EnteringContext, TemplateTy &Template,
                                      bool AllowInjectedClassName = false);
 
+  PartiallyAppliedConcept *BuildPartiallyAppliedConcept(
+      NestedNameSpecifierLoc NNS, SourceLocation ConceptKWLoc,
+      DeclarationNameInfo ConceptName, TemplateDecl *TD,
+      const TemplateArgumentListInfo &TemplateArgs);
+  PartiallyAppliedConcept *
+  ActOnPartiallyAppliedConcept(Scope *S, CXXScopeSpec &SS,
+                               SourceLocation ConceptKWLoc,
+                               TemplateIdAnnotation *TemplateId);
+
+  bool
+  ActOnUniversalTemplateParameterName(Scope *S, const UnqualifiedId &Name,
+                                      bool EnteringContext,
+                                      UniversalTemplateParamNameTy &Template);
+
   DeclResult ActOnClassTemplateSpecialization(
       Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
       SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
@@ -11754,6 +11811,12 @@ class Sema final : public SemaBase {
       SmallVectorImpl<TemplateArgument> &SugaredConverted,
       SmallVectorImpl<TemplateArgument> &CanonicalConverted);
 
+  bool CheckUniversalTemplateParameterArgument(
+      UniversalTemplateParmDecl *Param, TemplateArgumentLoc &Arg,
+      SmallVectorImpl<TemplateArgument> &SugaredConverted,
+      SmallVectorImpl<TemplateArgument> &CanonicalConverted,
+      CheckTemplateArgumentKind CTAK);
+
   /// Check a template argument against its corresponding
   /// template type parameter.
   ///
@@ -11761,18 +11824,22 @@ class Sema final : public SemaBase {
   /// returns true if an error occurred, and false otherwise.
   bool CheckTemplateArgument(TypeSourceInfo *Arg);
 
-  /// Check a template argument against its corresponding
+   /// Check a template argument against its corresponding
   /// non-type template parameter.
   ///
   /// This routine implements the semantics of C++ [temp.arg.nontype].
   /// If an error occurred, it returns ExprError(); otherwise, it
   /// returns the converted template argument. \p ParamType is the
   /// type of the non-type template parameter after it has been instantiated.
-  ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
+  ExprResult CheckTemplateArgument(NamedDecl *Param,
                                    QualType InstantiatedParamType, Expr *Arg,
                                    TemplateArgument &SugaredConverted,
                                    TemplateArgument &CanonicalConverted,
                                    CheckTemplateArgumentKind CTAK);
+  bool
+  CheckPartiallyAppliedConceptTemplateArgument(TemplateTemplateParmDecl *Param,
+                                               TemplateParameterList *Params,
+                                               TemplateArgumentLoc &Arg);
 
   /// Check a template argument against its corresponding
   /// template template parameter.
@@ -11783,6 +11850,11 @@ class Sema final : public SemaBase {
                                      TemplateParameterList *Params,
                                      TemplateArgumentLoc &Arg, bool IsDeduced);
 
+  bool CheckDeclCompatibleWithTemplateTemplate
+                                     (TemplateDecl *Template,
+                                      TemplateTemplateParmDecl *Param,
+                                      const TemplateArgumentLoc &Arg);
+
   void NoteTemplateLocation(const NamedDecl &Decl,
                             std::optional<SourceRange> ParamRange = {});
   void NoteTemplateParameterLocation(const NamedDecl &Decl);
@@ -11819,7 +11891,6 @@ class Sema final : public SemaBase {
     /// template<template<int Value> class Other> struct X;
     /// \endcode
     TPL_TemplateTemplateParmMatch,
-
     /// We are matching the template parameter lists of a template
     /// template argument against the template parameter lists of a template
     /// template parameter.
@@ -12067,7 +12138,7 @@ class Sema final : public SemaBase {
 
   void CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous,
                                 bool &AddToScope);
-  bool CheckConceptUseInDefinition(ConceptDecl *Concept, SourceLocation Loc);
+  bool CheckConceptUseInDefinition(NamedDecl *Concept, SourceLocation Loc);
 
   TypeResult ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
                                const CXXScopeSpec &SS,
@@ -13346,6 +13417,11 @@ class Sema final : public SemaBase {
   ExprResult SubstExpr(Expr *E,
                        const MultiLevelTemplateArgumentList &TemplateArgs);
 
+  NamedDecl *SubstUniversalTemplateParameter(
+      UniversalTemplateParmDecl *D,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      unsigned SubstitutedLevels = 0);
+
   // A RAII type used by the TemplateDeclInstantiator and TemplateInstantiator
   // to disable constraint evaluation, then restore the state.
   template <typename InstTy> struct ConstraintEvalRAII {
@@ -14477,6 +14553,12 @@ class Sema final : public SemaBase {
       const MultiLevelTemplateArgumentList &TemplateArgs,
       SourceRange TemplateIDRange);
 
+  ExprResult
+  SubstConceptTemplateArguments(const ConceptSpecializationExpr *CSE,
+                                const Expr *ConstraintExpr,
+                                const MultiLevelTemplateArgumentList &MLTAL,
+                                ArrayRef<TemplateArgument> Args);
+
   bool CheckInstantiatedFunctionTemplateConstraints(
       SourceLocation PointOfInstantiation, FunctionDecl *Decl,
       ArrayRef<TemplateArgument> TemplateArgs,
@@ -14495,8 +14577,8 @@ class Sema final : public SemaBase {
   DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,
                                 bool First = true);
 
-  const NormalizedConstraint *getNormalizedAssociatedConstraints(
-      NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
+  const NormalizedConstraint *getNormalizedAssociatedConstraints(NamedDecl *ConstrainedDecl,
+                                                                 ArrayRef<const Expr *> AssociatedConstraints);
 
   /// \brief Check whether the given declaration's associated constraints are
   /// at least as constrained than another declaration's according to the
diff --git a/clang/include/clang/Sema/SemaInternal.h b/clang/include/clang/Sema/SemaInternal.h
index d994d1819b442..9c2da783b817e 100644
--- a/clang/include/clang/Sema/SemaInternal.h
+++ b/clang/include/clang/Sema/SemaInternal.h
@@ -15,6 +15,7 @@
 #define LLVM_CLANG_SEMA_SEMAINTERNAL_H
 
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
@@ -65,6 +66,9 @@ inline std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) {
   if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
     return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
 
+  if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(ND))
+    return std::make_pair(UTP->getDepth(), UTP->getIndex());
+
   const auto *TTP = cast<TemplateTemplateParmDecl>(ND);
   return std::make_pair(TTP->getDepth(), TTP->getIndex());
 }
diff --git a/clang/lib/AST/ASTConcept.cpp b/clang/lib/AST/ASTConcept.cpp
index d8efbe44dbecb..f787a2cec7eb6 100644
--- a/clang/lib/AST/ASTConcept.cpp
+++ b/clang/lib/AST/ASTConcept.cpp
@@ -14,6 +14,9 @@
 #include "clang/AST/ASTConcept.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/TemplateBase.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 
@@ -88,7 +91,7 @@ ConceptReference *
 ConceptReference::Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
                          SourceLocation TemplateKWLoc,
                          DeclarationNameInfo ConceptNameInfo,
-                         NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
+                         NamedDecl *FoundDecl, TemplateDecl *NamedConcept,
                          const ASTTemplateArgumentListInfo *ArgsAsWritten) {
   return new (C) ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo,
                                   FoundDecl, NamedConcept, ArgsAsWritten);
@@ -110,3 +113,55 @@ void ConceptReference::print(llvm::raw_ostream &OS,
     OS << ">";
   }
 }
+
+
+PartiallyAppliedConcept *PartiallyAppliedConcept::Create(
+    const ASTContext &C, NestedNameSpecifierLoc NNS,
+    DeclarationNameInfo ConceptNameInfo, SourceLocation ConceptKWLoc,
+    NamedDecl *FoundDecl, TemplateDecl *NamedConcept,
+    const TemplateArgumentListInfo &TemplateArgs) {
+
+  return new (C) PartiallyAppliedConcept(
+      NNS, ConceptNameInfo, ConceptKWLoc, FoundDecl, NamedConcept,
+      ASTTemplateArgumentListInfo::Create(C, TemplateArgs));
+}
+
+TemplateArgumentDependence PartiallyAppliedConcept::getDependence() const {
+  auto TA = TemplateArgumentDependence::None;
+  if (isa<TemplateTemplateParmDecl>(getNamedConcept())) {
+    TA |= TemplateArgumentDependence::DependentInstantiation;
+  }
+  const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
+                               TemplateArgumentDependence::UnexpandedPack;
+  for (const TemplateArgumentLoc &ArgLoc :
+       getTemplateArgsAsWritten()->arguments()) {
+    TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
+    if (TA == InterestingDeps)
+      break;
+  }
+  return TA;
+}
+
+void PartiallyAppliedConcept::Profile(
+    llvm::FoldingSetNodeID &ID, const ASTContext &C,
+    const TemplateDecl *NamedConcept,
+    const ASTTemplateArgumentListInfo *ArgsAsWritten) {
+  ID.AddPointer(NamedConcept);
+  ID.AddInteger(ArgsAsWritten->getNumTemplateArgs());
+  for (auto &Arg : ArgsAsWritten->arguments())
+    Arg.getArgument().Profile(ID, C);
+}
+
+const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+                                             PartiallyAppliedConcept &C) {
+  std::string NameStr;
+  llvm::raw_string_ostream OS(NameStr);
+  LangOptions LO;
+  LO.CPlusPlus = true;
+  LO.Bool = true;
+  OS << '\'';
+  C.print(OS, PrintingPolicy(LO));
+  OS << '\'';
+  OS.flush();
+  return DB << NameStr;
+}
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index fd8aa8de79b49..ca47d719deac6 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -46,6 +46,7 @@
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/AddressSpaces.h"
@@ -705,6 +706,7 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
   ID.AddInteger(Parm->getDepth());
   ID.AddInteger(Parm->getPosition());
   ID.AddBoolean(Parm->isParameterPack());
+  ID.AddInteger(Parm->kind());
 
   TemplateParameterList *Params = Parm->getTemplateParameters();
   ID.AddInteger(Params->size());
@@ -739,8 +741,14 @@ ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
       continue;
     }
 
+    if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(*P)) {
+      ID.AddInteger(2);
+      ID.AddBoolean(UTP->isParameterPack());
+      continue;
+    }
+
     auto *TTP = cast<TemplateTemplateParmDecl>(*P);
-    ID.AddInteger(2);
+    ID.AddInteger(3);
     Profile(ID, C, TTP);
   }
 }
@@ -808,14 +816,21 @@ ASTContext::getCanonicalTemplateTemplateParmDecl(
                                                 TInfo);
       }
       CanonParams.push_back(Param);
-    } else
+    } else if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(*P)) {
+      UniversalTemplateParmDecl *Param = UniversalTemplateParmDecl::Create(
+          *this, getTranslationUnitDecl(), SourceLocation(), UTP->getDepth(),
+          UTP->getIndex(), UTP->isParameterPack(), nullptr);
+      CanonParams.push_back(Param);
+    } else {
       CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
                                            cast<TemplateTemplateParmDecl>(*P)));
+    }
   }
 
   TemplateTemplateParmDecl *CanonTTP = TemplateTemplateParmDecl::Create(
       *this, getTranslationUnitDecl(), SourceLocation(), TTP->getDepth(),
-      TTP->getPosition(), TTP->isParameterPack(), nullptr, /*Typename=*/false,
+      TTP->getPosition(), TTP->isParameterPack(), nullptr,  TTP->kind(),
+      /*Typename=*/false,
       TemplateParameterList::Create(*this, SourceLocation(), SourceLocation(),
                                     CanonParams, SourceLocation(),
                                     /*RequiresClause=*/nullptr));
@@ -5617,6 +5632,16 @@ TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
       E = new (*this)
           PackExpansionExpr(DependentTy, E, NTTP->getLocation(), std::nullopt);
     Arg = TemplateArgument(E);
+  } else if (auto *UTP = dyn_cast<UniversalTemplateParmDecl>(Param)) {
+    UniversalTemplateParameterName *UTPN =
+        new (*this) UniversalTemplateParameterName(
+            Param->getLocation(),
+            DeclarationNameInfo(Param->getDeclName(), Param->getLocation()),
+            UTP);
+    if (UTP->isParameterPack())
+      Arg = TemplateArgument(UTPN, std::optional<unsigned>());
+    else
+      Arg = TemplateArgument(UTPN);
   } else {
     auto *TTP = cast<TemplateTemplateParmDecl>(Param);
     TemplateName Name = getQualifiedTemplateName(
@@ -6206,7 +6231,7 @@ QualType ASTContext::getUnaryTransformType(QualType BaseType,
 
 QualType ASTContext::getAutoTypeInternal(
     QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent,
-    bool IsPack, ConceptDecl *TypeConstraintConcept,
+    bool IsPack, TemplateDecl *TypeConstraintConcept,
     ArrayRef<TemplateArgument> TypeConstraintArgs, bool IsCanon) const {
   if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto &&
       !TypeConstraintConcept && !IsDependent)
@@ -6226,7 +6251,7 @@ QualType ASTContext::getAutoTypeInternal(
       Canon = DeducedType.getCanonicalType();
     } else if (TypeConstraintConcept) {
       bool AnyNonCanonArgs = false;
-      ConceptDecl *CanonicalConcept = TypeConstraintConcept->getCanonicalDecl();
+      TemplateDecl *CanonicalConcept = cast<TemplateDecl>(TypeConstraintConcept->getCanonicalDecl());
       auto CanonicalConceptArgs = ::getCanonicalTemplateArguments(
           *this, TypeConstraintArgs, AnyNonCanonArgs);
       if (CanonicalConcept != TypeConstraintConcept || AnyNonCanonArgs) {
@@ -6261,7 +6286,7 @@ QualType ASTContext::getAutoTypeInternal(
 QualType
 ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                         bool IsDependent, bool IsPack,
-                        ConceptDecl *TypeConstraintConcept,
+                        TemplateDecl *TypeConstraintConcept,
                         ArrayRef<TemplateArgument> TypeConstraintArgs) const {
   assert((!IsPack || IsDependent) && "only use IsPack for a dependent pack");
   assert((!IsDependent || DeducedType.isNull()) &&
@@ -7283,12 +7308,27 @@ ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
     case TemplateArgument::Expression:
       return Arg;
 
+    // FIXME corentin: do concept needs to be canonicalized?
+    case TemplateArgument::Concept:
+      return Arg;
+
     case TemplateArgument::Declaration: {
       auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
       return TemplateArgument(D, getCanonicalType(Arg.getParamTypeForDecl()),
                               Arg.getIsDefaulted());
     }
 
+    case TemplateArgument::Universal: {
+      // TODO Corentin: canonicalization
+      UniversalTemplateParameterName *UTPN =
+          Arg.getAsUniversalTemplateParameterName();
+      return TemplateArgument(UTPN);
+    }
+    case TemplateArgument::UniversalExpansion: {
+      UniversalTemplateParameterName *UTPN =
+          Arg.getAsUniversalTemplateParameterOrPattern();
+      return TemplateArgument(UTPN, Arg.getNumTemplateExpansions());
+    }
     case TemplateArgument::NullPtr:
       return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
                               /*isNullPtr*/ true, Arg.getIsDefaulted());
@@ -9880,6 +9920,16 @@ ASTContext::getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
   return TemplateName(Subst);
 }
 
+UniversalTemplateParameterName *ASTContext::getUniversalTemplateParameterName(
+    SourceLocation Loc, DeclarationNameInfo Name,
+    UniversalTemplateParmDecl *Decl) const {
+  // TODO Corentin: canonicalize?
+  UniversalTemplateParameterName *UTPN =
+      new (*this, alignof(UniversalTemplateParameterName))
+          UniversalTemplateParameterName(Loc, Name, Decl);
+  return UTPN;
+}
+
 /// Retrieve the template name that represents a template name
 /// deduced from a specialization.
 TemplateName
@@ -13731,8 +13781,8 @@ static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X,
     if (KW != AY->getKeyword())
       return QualType();
 
-    ConceptDecl *CD = ::getCommonDecl(AX->getTypeConstraintConcept(),
-                                      AY->getTypeConstraintConcept());
+    TemplateDecl *CD = ::getCommonDecl(AX->getTypeConstraintConcept(),
+                                       AY->getTypeConstraintConcept());
     SmallVector<TemplateArgument, 8> As;
     if (CD &&
         getCommonTemplateArguments(Ctx, As, AX->getTypeConstraintArguments(),
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index bba97e289da2e..e4b02c294e721 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -559,6 +559,8 @@ namespace clang {
     ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
     ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
     ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
+    ExpectedDecl VisitUniversalTemplateParmDecl(UniversalTemplateParmDecl *D);
+
     ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
     ExpectedDecl VisitClassTemplateSpecializationDecl(
                                             ClassTemplateSpecializationDecl *D);
@@ -6038,8 +6040,7 @@ ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
           ToD, D, Importer.getToContext(),
           Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
           D->getDepth(), D->getPosition(), D->isParameterPack(),
-          (*NameOrErr).getAsIdentifierInfo(), D->wasDeclaredWithTypename(),
-          *TemplateParamsOrErr))
+          (*NameOrErr).getAsIdentifierInfo(), D->kind(), D->wasDeclaredWithTypename(), *TemplateParamsOrErr))
     return ToD;
 
   if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
@@ -6048,6 +6049,11 @@ ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   return ToD;
 }
 
+ExpectedDecl
+ASTNodeImporter::VisitUniversalTemplateParmDecl(UniversalTemplateParmDecl *D) {
+  assert(false && "TODO CORENTIN");
+}
+
 // Returns the definition for a (forward) declaration of a TemplateDecl, if
 // it has any definition in the redecl chain.
 template <typename T> static auto getTemplateDefinition(T *D) -> T * {
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp
index 21f0562f9d72a..e50c0e6499769 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -657,6 +657,21 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      ArrayRef<TemplateArgument> Args1,
                                      ArrayRef<TemplateArgument> Args2);
 
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ArrayRef<TemplateArgumentLoc> Args1,
+                                     ArrayRef<TemplateArgumentLoc> Args2);
+
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     const PartiallyAppliedConcept *C1,
+                                     const PartiallyAppliedConcept *C2) {
+  if (!IsStructurallyEquivalent(Context, C1->getNamedConcept(),
+                                C2->getNamedConcept()))
+     return false;
+  return IsStructurallyEquivalent(Context,
+                                  C1->getTemplateArgsAsWritten()->arguments(),
+                                  C2->getTemplateArgsAsWritten()->arguments());
+}
+
 /// Determine whether two template arguments are equivalent.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      const TemplateArgument &Arg1,
@@ -689,6 +704,11 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     return IsStructurallyEquivalent(Context, Arg1.getAsTemplate(),
                                     Arg2.getAsTemplate());
 
+  case TemplateArgument::Concept:
+    return IsStructurallyEquivalent(Context,
+                                    Arg1.getAsPartiallyAppliedConcept(),
+                                    Arg2.getAsPartiallyAppliedConcept());
+
   case TemplateArgument::TemplateExpansion:
     return IsStructurallyEquivalent(Context,
                                     Arg1.getAsTemplateOrTemplatePattern(),
@@ -722,6 +742,19 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   return true;
 }
 
+/// Determine structural equivalence of two template argument lists.
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ArrayRef<TemplateArgumentLoc> Args1,
+                                     ArrayRef<TemplateArgumentLoc> Args2) {
+  if (Args1.size() != Args2.size())
+    return false;
+  for (unsigned I = 0, N = Args1.size(); I != N; ++I) {
+    if (!IsStructurallyEquivalent(Context, Args1[I], Args2[I]))
+      return false;
+  }
+  return true;
+}
+
 /// Determine whether two template argument locations are equivalent.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      const TemplateArgumentLoc &Arg1,
@@ -2070,7 +2103,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   // Check template parameter lists.
-  return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
+  return D1->kind() == D2->kind() && IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
                                   D2->getTemplateParameters());
 }
 
diff --git a/clang/lib/AST/CMakeLists.txt b/clang/lib/AST/CMakeLists.txt
index 6195a16c2c68d..a8bc4f66fae0d 100644
--- a/clang/lib/AST/CMakeLists.txt
+++ b/clang/lib/AST/CMakeLists.txt
@@ -127,6 +127,7 @@ add_clang_library(clangAST
   Type.cpp
   TypeLoc.cpp
   TypePrinter.cpp
+  UniversalTemplateParameterName.cpp
   VTableBuilder.cpp
   VTTBuilder.cpp
 
diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp
index 6ef49790481ac..3cbe2c062e26b 100644
--- a/clang/lib/AST/ComputeDependence.cpp
+++ b/clang/lib/AST/ComputeDependence.cpp
@@ -805,7 +805,7 @@ clang::computeDependence(OverloadExpr *E, bool KnownDependent,
                              ~NestedNameSpecifierDependence::Dependent);
   for (auto *D : E->decls()) {
     if (D->getDeclContext()->isDependentContext() ||
-        isa<UnresolvedUsingValueDecl>(D))
+        isa<UnresolvedUsingValueDecl>(D) || isa<TemplateTemplateParmDecl>(D))
       Deps |= ExprDependence::TypeValueInstantiation;
   }
   // If we have explicit template arguments, check for dependent
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index a14b1b33d35ef..0173f030c2f48 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -173,6 +173,7 @@ static std::optional<Visibility> getExplicitVisibility(const NamedDecl *D,
                                                        LVComputationKind kind) {
   assert(!kind.IgnoreExplicitVisibility &&
          "asking for explicit visibility when we shouldn't be");
+
   return D->getExplicitVisibility(kind.getExplicitVisibilityKind());
 }
 
@@ -256,6 +257,10 @@ LinkageInfo LinkageComputer::getLVForTemplateParameterList(
     if (isa<TemplateTypeParmDecl>(P))
       continue;
 
+    // FIXME: Corentin: do we need to do something here?
+    if (isa<UniversalTemplateParmDecl>(P))
+      continue;
+
     // Non-type template parameters can be restricted by the value type, e.g.
     //   template <enum X> class A { ... };
     // We have to be careful here, though, because we can be dealing with
@@ -355,6 +360,13 @@ LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
         LV.merge(getLVForDecl(Template, computation));
       continue;
 
+    // FIXME corentin
+    case TemplateArgument::Concept:
+      if (TemplateDecl *Template =
+              Arg.getAsPartiallyAppliedConcept()->getNamedConcept())
+        LV.merge(getLVForDecl(Template, computation));
+      continue;
+
     case TemplateArgument::Pack:
       LV.merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
       continue;
@@ -1228,6 +1240,9 @@ getExplicitVisibilityAux(const NamedDecl *ND,
                          bool IsMostRecent) {
   assert(!IsMostRecent || ND == ND->getMostRecentDecl());
 
+  if(isa<ConceptDecl>(ND))
+      return {};
+
   // Check the declaration itself first.
   if (std::optional<Visibility> V = getVisibilityOf(ND, kind))
     return V;
diff --git a/clang/lib/AST/DeclBase.cpp b/clang/lib/AST/DeclBase.cpp
index f42857f20efc4..7e883806e0bc2 100644
--- a/clang/lib/AST/DeclBase.cpp
+++ b/clang/lib/AST/DeclBase.cpp
@@ -236,6 +236,8 @@ bool Decl::isTemplateParameterPack() const {
     return NTTP->isParameterPack();
   if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
     return TTP->isParameterPack();
+  if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(this))
+    return UTP->isParameterPack();
   return false;
 }
 
@@ -935,6 +937,7 @@ unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
 
     case ClassTemplate:
     case TemplateTemplateParm:
+    case UniversalTemplateParm:
     case TypeAliasTemplate:
       return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
 
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 6fe817c5ef1c6..fbf76fcf9e80d 100644
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -77,7 +77,8 @@ TemplateParameterList::TemplateParameterList(const ASTContext& C,
           (TTP->getTemplateParameters()->containsUnexpandedParameterPack() ||
            DefaultTemplateArgumentContainsUnexpandedPack(*TTP))) {
         ContainsUnexpandedParameterPack = true;
-      }
+    } else if (isa<UniversalTemplateParmDecl>(P)) {
+      //
     } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
       if (!IsPack && DefaultTemplateArgumentContainsUnexpandedPack(*TTP)) {
         ContainsUnexpandedParameterPack = true;
@@ -100,6 +101,8 @@ TemplateParameterList::TemplateParameterList(const ASTContext& C,
   }
 }
 
+}
+
 bool TemplateParameterList::containsUnexpandedParameterPack() const {
   if (ContainsUnexpandedParameterPack)
     return true;
@@ -162,8 +165,14 @@ void TemplateParameterList::Profile(llvm::FoldingSetNodeID &ID,
                                                         /*Canonical=*/true);
       continue;
     }
+    if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(D)) {
+      ID.AddInteger(2);
+      ID.AddBoolean(UTP->isParameterPack());
+      continue;
+    }
     const auto *TTP = cast<TemplateTemplateParmDecl>(D);
-    ID.AddInteger(2);
+    ID.AddInteger(3);
+    ID.AddInteger(TTP->kind());
     ID.AddBoolean(TTP->isParameterPack());
     TTP->getTemplateParameters()->Profile(ID, C);
   }
@@ -186,7 +195,8 @@ unsigned TemplateParameterList::getMinRequiredArguments() const {
     } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
       if (NTTP->hasDefaultArgument())
         break;
-    } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
+    } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P);
+               TTP && TTP->hasDefaultArgument())
       break;
 
     ++NumRequiredArgs;
@@ -204,6 +214,8 @@ unsigned TemplateParameterList::getDepth() const {
     return TTP->getDepth();
   else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
     return NTTP->getDepth();
+  else if (const auto *UTP = dyn_cast<UniversalTemplateParmDecl>(FirstParm))
+    return UTP->getDepth();
   else
     return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
 }
@@ -830,40 +842,43 @@ void TemplateTemplateParmDecl::anchor() {}
 
 TemplateTemplateParmDecl::TemplateTemplateParmDecl(
     DeclContext *DC, SourceLocation L, unsigned D, unsigned P,
-    IdentifierInfo *Id, bool Typename, TemplateParameterList *Params,
+    IdentifierInfo *Id, TemplateNameKind Kind, bool Typename,
+    TemplateParameterList *Params,
     ArrayRef<TemplateParameterList *> Expansions)
     : TemplateDecl(TemplateTemplateParm, DC, L, Id, Params),
       TemplateParmPosition(D, P), Typename(Typename), ParameterPack(true),
-      ExpandedParameterPack(true), NumExpandedParams(Expansions.size()) {
+      ExpandedParameterPack(true), NumExpandedParams(Expansions.size()),
+      ParameterKind(Kind) {
   if (!Expansions.empty())
     std::uninitialized_copy(Expansions.begin(), Expansions.end(),
                             getTrailingObjects<TemplateParameterList *>());
 }
 
-TemplateTemplateParmDecl *
-TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
-                                 SourceLocation L, unsigned D, unsigned P,
-                                 bool ParameterPack, IdentifierInfo *Id,
-                                 bool Typename, TemplateParameterList *Params) {
-  return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
-                                              Typename, Params);
+TemplateTemplateParmDecl *TemplateTemplateParmDecl::Create(
+    const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D,
+    unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateNameKind Kind,
+    bool Typename,
+    TemplateParameterList *Params) {
+  return new (C, DC)
+      TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, Kind, Typename, Params);
 }
 
 TemplateTemplateParmDecl *
 TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
                                  SourceLocation L, unsigned D, unsigned P,
-                                 IdentifierInfo *Id, bool Typename,
+                                 IdentifierInfo *Id, TemplateNameKind Kind, bool Typename,
                                  TemplateParameterList *Params,
                                  ArrayRef<TemplateParameterList *> Expansions) {
   return new (C, DC,
               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
-      TemplateTemplateParmDecl(DC, L, D, P, Id, Typename, Params, Expansions);
+      TemplateTemplateParmDecl(DC, L, D, P, Id, Kind, Typename, Params, Expansions);
 }
 
 TemplateTemplateParmDecl *
 TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID) {
-  return new (C, ID) TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0,
-                                              false, nullptr, false, nullptr);
+  return new (C, ID)
+      TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
+                               TemplateNameKind::TNK_Type_template, false, nullptr, std::nullopt);
 }
 
 TemplateTemplateParmDecl *
@@ -872,7 +887,8 @@ TemplateTemplateParmDecl::CreateDeserialized(ASTContext &C, GlobalDeclID ID,
   auto *TTP =
       new (C, ID, additionalSizeToAlloc<TemplateParameterList *>(NumExpansions))
           TemplateTemplateParmDecl(nullptr, SourceLocation(), 0, 0, nullptr,
-                                   false, nullptr, std::nullopt);
+                                   TemplateNameKind::TNK_Type_template, false, nullptr,
+                                   std::nullopt);
   TTP->NumExpandedParams = NumExpansions;
   return TTP;
 }
@@ -890,6 +906,13 @@ void TemplateTemplateParmDecl::setDefaultArgument(
     DefaultArgument.set(new (C) TemplateArgumentLoc(DefArg));
 }
 
+UniversalTemplateParmDecl *
+UniversalTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
+                                  SourceLocation L, unsigned D, unsigned P,
+                                  bool ParameterPack, IdentifierInfo *Id) {
+  return new (C, DC) UniversalTemplateParmDecl(DC, L, D, P, ParameterPack, Id);
+}
+
 //===----------------------------------------------------------------------===//
 // TemplateArgumentList Implementation
 //===----------------------------------------------------------------------===//
@@ -1562,7 +1585,9 @@ createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
   // template <typename T, ...Ints> class IntSeq
   auto *TemplateTemplateParm = TemplateTemplateParmDecl::Create(
       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
-      /*ParameterPack=*/false, /*Id=*/nullptr, /*Typename=*/false, TPL);
+      /*ParameterPack=*/false, /*Id=*/nullptr,
+      TemplateNameKind::TNK_Type_template,
+      /*Typename=*/false, TPL);
   TemplateTemplateParm->setImplicit(true);
 
   // typename T
@@ -1624,6 +1649,7 @@ static TemplateParameterList *createBuiltinCommonTypeList(const ASTContext &C,
   auto *BaseTemplate = TemplateTemplateParmDecl::Create(
       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/0,
       /*ParameterPack=*/false, /*Id=*/nullptr,
+      TemplateNameKind::TNK_Type_template,
       /*Typename=*/false, BaseTemplateList);
 
   // class TypeMember
@@ -1641,6 +1667,7 @@ static TemplateParameterList *createBuiltinCommonTypeList(const ASTContext &C,
   auto *HasTypeMember = TemplateTemplateParmDecl::Create(
       C, DC, SourceLocation(), /*Depth=*/0, /*Position=*/1,
       /*ParameterPack=*/false, /*Id=*/nullptr,
+      TemplateNameKind::TNK_Type_template,
       /*Typename=*/false, HasTypeMemberList);
 
   // class HasNoTypeMember
@@ -1685,6 +1712,20 @@ BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
                    createBuiltinTemplateParameterList(C, DC, BTK)),
       BTK(BTK) {}
 
+/*void ConceptReference::print(llvm::raw_ostream &OS,
+                             PrintingPolicy Policy) const {
+  if (NestedNameSpec)
+    NestedNameSpec.getNestedNameSpecifier()->print(OS, Policy);
+  ConceptName.printName(OS, Policy);
+  if (hasExplicitTemplateArgs()) {
+    OS << "<";
+    // FIXME: Find corresponding parameter for argument
+    for (auto &ArgLoc : ArgsAsWritten->arguments())
+      ArgLoc.getArgument().print(Policy, OS, /*IncludeType/ false);
+    OS << ">";
+  }
+}*/
+
 TemplateParamObjectDecl *TemplateParamObjectDecl::Create(const ASTContext &C,
                                                          QualType T,
                                                          const APValue &V) {
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
index 83ce404add5f5..dc50ab6f1d286 100644
--- a/clang/lib/AST/ExprCXX.cpp
+++ b/clang/lib/AST/ExprCXX.cpp
@@ -396,6 +396,16 @@ SourceLocation CXXPseudoDestructorExpr::getEndLoc() const {
   return End;
 }
 
+static bool UnresolvedLookupExprIsVariableOrConceptParameterPack(
+    UnresolvedSetIterator Begin, UnresolvedSetIterator End) {
+  if (std::distance(Begin, End) != 1)
+    return false;
+  NamedDecl *ND = *Begin;
+  if (auto *TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(ND))
+    return TTP->isParameterPack();
+  return false;
+}
+
 // UnresolvedLookupExpr
 UnresolvedLookupExpr::UnresolvedLookupExpr(
     const ASTContext &Context, CXXRecordDecl *NamingClass,
@@ -406,7 +416,8 @@ UnresolvedLookupExpr::UnresolvedLookupExpr(
     bool KnownInstantiationDependent)
     : OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,
                    TemplateKWLoc, NameInfo, TemplateArgs, Begin, End,
-                   KnownDependent, KnownInstantiationDependent, false),
+                   KnownDependent, KnownInstantiationDependent,
+                   UnresolvedLookupExprIsVariableOrConceptParameterPack(Begin, End)),
       NamingClass(NamingClass) {
   UnresolvedLookupExprBits.RequiresADL = RequiresADL;
 }
@@ -1710,8 +1721,8 @@ SizeOfPackExpr *SizeOfPackExpr::CreateDeserialized(ASTContext &Context,
   return new (Storage) SizeOfPackExpr(EmptyShell(), NumPartialArgs);
 }
 
-NonTypeTemplateParmDecl *SubstNonTypeTemplateParmExpr::getParameter() const {
-  return cast<NonTypeTemplateParmDecl>(
+NamedDecl *SubstNonTypeTemplateParmExpr::getParameter() const {
+  return cast<NamedDecl>(
       getReplacedTemplateParameterList(getAssociatedDecl())->asArray()[Index]);
 }
 
@@ -1754,9 +1765,14 @@ QualType SubstNonTypeTemplateParmExpr::getParameterType(
     const ASTContext &Context) const {
   // Note that, for a class type NTTP, we will have an lvalue of type 'const
   // T', so we can't just compute this from the type and value category.
+
+  QualType Type = getType();
+  if (isa<UniversalTemplateParmDecl>(getParameter()))
+    Type = getReplacement()->getType();
+
   if (isReferenceParameter())
-    return Context.getLValueReferenceType(getType());
-  return getType().getUnqualifiedType();
+    return Context.getLValueReferenceType(Type);
+  return Type.getUnqualifiedType();
 }
 
 SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index b6e1da0c3192d..69a13fca38a3c 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -535,7 +535,7 @@ class CXXNameMangler {
   void mangleUnqualifiedBlock(const BlockDecl *Block);
   void mangleTemplateParamDecl(const NamedDecl *Decl);
   void mangleTemplateParameterList(const TemplateParameterList *Params);
-  void mangleTypeConstraint(const ConceptDecl *Concept,
+  void mangleTypeConstraint(const TemplateDecl *Concept,
                             ArrayRef<TemplateArgument> Arguments);
   void mangleTypeConstraint(const TypeConstraint *Constraint);
   void mangleRequiresClause(const Expr *RequiresClause);
@@ -2056,7 +2056,7 @@ void CXXNameMangler::mangleTemplateParameterList(
 }
 
 void CXXNameMangler::mangleTypeConstraint(
-    const ConceptDecl *Concept, ArrayRef<TemplateArgument> Arguments) {
+    const TemplateDecl *Concept, ArrayRef<TemplateArgument> Arguments) {
   const DeclContext *DC = Context.getEffectiveDeclContext(Concept);
   if (!Arguments.empty())
     mangleTemplateName(Concept, Arguments);
@@ -5931,6 +5931,9 @@ struct CXXNameMangler::TemplateArgManglingInfo {
       return NTTP->getType()->isInstantiationDependentType() ||
              NTTP->getType()->getContainedDeducedType();
 
+    if(isa<UniversalTemplateParmDecl>(Param))
+      return true;
+
     // For a template template parameter, the template-head might differ from
     // that of the template.
     auto *TTP = cast<TemplateTemplateParmDecl>(Param);
diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp
index 1929314363817..ff44001780d8e 100644
--- a/clang/lib/AST/ODRHash.cpp
+++ b/clang/lib/AST/ODRHash.cpp
@@ -510,6 +510,11 @@ class ODRDeclVisitor : public ConstDeclVisitor<ODRDeclVisitor> {
     Inherited::VisitTemplateTemplateParmDecl(D);
   }
 
+  void VisitUniversalTemplateParmDecl(const UniversalTemplateParmDecl *D) {
+    Hash.AddBoolean(D->isParameterPack());
+    Inherited::VisitUniversalTemplateParmDecl(D);
+  }
+
   void VisitTemplateDecl(const TemplateDecl *D) {
     Hash.AddTemplateParameterList(D->getTemplateParameters());
 
diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp
index ad4281986f668..1ce962f47aeb7 100644
--- a/clang/lib/AST/StmtProfile.cpp
+++ b/clang/lib/AST/StmtProfile.cpp
@@ -2455,6 +2455,15 @@ void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
     VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
     break;
 
+  case TemplateArgument::Concept: {
+    PartiallyAppliedConcept* C = Arg.getAsPartiallyAppliedConcept();
+    VisitDecl(C->getNamedConcept());
+    for (const auto &P : C->getTemplateArgsAsWritten()->arguments()) {
+      VisitTemplateArgument(P.getArgument());
+    }
+    break;
+  }
+
   case TemplateArgument::Declaration:
     VisitType(Arg.getParamTypeForDecl());
     // FIXME: Do we need to recursively decompose template parameter objects?
diff --git a/clang/lib/AST/TemplateBase.cpp b/clang/lib/AST/TemplateBase.cpp
index 2e6839e948d9d..d753cf4a5d7a1 100644
--- a/clang/lib/AST/TemplateBase.cpp
+++ b/clang/lib/AST/TemplateBase.cpp
@@ -277,6 +277,11 @@ TemplateArgumentDependence TemplateArgument::getDependence() const {
   case Template:
     return toTemplateArgumentDependence(getAsTemplate().getDependence());
 
+  case Universal:
+  case UniversalExpansion:
+    return TemplateArgumentDependence::Dependent |
+           TemplateArgumentDependence::Instantiation;
+
   case TemplateExpansion:
     return TemplateArgumentDependence::Dependent |
            TemplateArgumentDependence::Instantiation;
@@ -303,6 +308,10 @@ TemplateArgumentDependence TemplateArgument::getDependence() const {
               TemplateArgumentDependence::Instantiation;
     return Deps;
 
+  case Concept: {
+    Deps = getAsPartiallyAppliedConcept()->getDependence();
+    return Deps;
+  }
   case Pack:
     for (const auto &P : pack_elements())
       Deps |= P.getDependence();
@@ -328,8 +337,11 @@ bool TemplateArgument::isPackExpansion() const {
   case Pack:
   case Template:
   case NullPtr:
+  case Concept:
+  case Universal:
     return false;
 
+  case UniversalExpansion:
   case TemplateExpansion:
     return true;
 
@@ -343,15 +355,30 @@ bool TemplateArgument::isPackExpansion() const {
   llvm_unreachable("Invalid TemplateArgument Kind!");
 }
 
+bool TemplateArgument::isConceptOrConceptTemplateParameter() const {
+  bool isConcept = getKind() == TemplateArgument::Concept;
+  if (!isConcept && getKind() == TemplateArgument::Template) {
+    if (isa<ConceptDecl>(getAsTemplate().getAsTemplateDecl()))
+      isConcept = true;
+    else if (auto *TTP = dyn_cast_if_present<TemplateTemplateParmDecl>(
+                 getAsTemplate().getAsTemplateDecl()))
+      isConcept = TTP->kind() == TNK_Concept_template;
+  }
+  return isConcept;
+}
+
 bool TemplateArgument::containsUnexpandedParameterPack() const {
   return getDependence() & TemplateArgumentDependence::UnexpandedPack;
 }
 
 std::optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
-  assert(getKind() == TemplateExpansion);
-  if (TemplateArg.NumExpansions)
+  assert(getKind() == TemplateExpansion || getKind() == UniversalExpansion);
+  if (getKind() == TemplateExpansion && TemplateArg.NumExpansions)
     return TemplateArg.NumExpansions - 1;
 
+  if (UniversalArg.NumExpansions)
+    return UniversalArg.NumExpansions - 1;
+
   return std::nullopt;
 }
 
@@ -362,6 +389,9 @@ QualType TemplateArgument::getNonTypeTemplateArgumentType() const {
   case TemplateArgument::Template:
   case TemplateArgument::TemplateExpansion:
   case TemplateArgument::Pack:
+  case TemplateArgument::Concept:
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion:
     return QualType();
 
   case TemplateArgument::Integral:
@@ -410,6 +440,17 @@ void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
     ID.AddPointer(TemplateArg.Name);
     break;
 
+  case Concept:
+    getAsPartiallyAppliedConcept()->Profile(ID, Context);
+    break;
+
+  case UniversalExpansion:
+    ID.AddInteger(UniversalArg.NumExpansions);
+    [[fallthrough]];
+  case Universal:
+    getAsUniversalTemplateParameterOrPattern()->Profile(Context, ID);
+    break;
+
   case Integral:
     getIntegralType().Profile(ID);
     getAsIntegral().Profile(ID);
@@ -446,6 +487,27 @@ bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
     return TemplateArg.Name == Other.TemplateArg.Name &&
            TemplateArg.NumExpansions == Other.TemplateArg.NumExpansions;
 
+  case Universal:
+  case UniversalExpansion:
+    return UniversalArg.D == Other.UniversalArg.D &&
+           UniversalArg.NumExpansions == Other.UniversalArg.NumExpansions;
+
+  case Concept: {
+    PartiallyAppliedConcept *C = getAsPartiallyAppliedConcept();
+    PartiallyAppliedConcept *OC = Other.getAsPartiallyAppliedConcept();
+    if (C->getNamedConcept() != OC->getNamedConcept())
+      return false;
+    const ASTTemplateArgumentListInfo *Args = C->getTemplateArgsAsWritten();
+    const ASTTemplateArgumentListInfo *OArgs = OC->getTemplateArgsAsWritten();
+    if (Args->getNumTemplateArgs() != OArgs->getNumTemplateArgs())
+      return false;
+    for (unsigned I = 0; I < Args->getNumTemplateArgs(); I++)
+      if (!Args->arguments()[I].getArgument().structurallyEquals(
+              OArgs->arguments()[I].getArgument()))
+        return false;
+    return true;
+  }
+
   case Declaration:
     return getAsDecl() == Other.getAsDecl() &&
            getParamTypeForDecl() == Other.getParamTypeForDecl();
@@ -489,12 +551,17 @@ TemplateArgument TemplateArgument::getPackExpansionPattern() const {
   case TemplateExpansion:
     return TemplateArgument(getAsTemplateOrTemplatePattern());
 
+  case UniversalExpansion:
+    return TemplateArgument(getAsUniversalTemplateParameterOrPattern());
+
   case Declaration:
   case Integral:
   case StructuralValue:
   case Pack:
   case Null:
   case Template:
+  case Concept:
+  case Universal:
   case NullPtr:
     return TemplateArgument();
   }
@@ -553,6 +620,19 @@ void TemplateArgument::print(const PrintingPolicy &Policy, raw_ostream &Out,
     Out << "...";
     break;
 
+  case Universal:
+    getAsUniversalTemplateParameterName()->print(Out, Policy);
+    break;
+
+  case UniversalExpansion:
+    getAsUniversalTemplateParameterOrPattern()->print(Out, Policy);
+    Out << "...";
+    break;
+
+  case Concept:
+    getAsPartiallyAppliedConcept()->print(Out, Policy);
+    break;
+
   case Integral:
     printIntegral(*this, Out, Policy, IncludeType);
     break;
@@ -604,6 +684,18 @@ SourceRange TemplateArgumentLoc::getSourceRange() const {
                          getTemplateNameLoc());
     return SourceRange(getTemplateNameLoc());
 
+  case TemplateArgument::Universal:
+    return getArgument().getAsUniversalTemplateParameterName()->getLocation();
+
+  case TemplateArgument::UniversalExpansion:
+    return SourceRange(
+        getArgument().getAsUniversalTemplateParameterOrPattern()->getLocation(),
+        getUniversalEllipsisLoc());
+
+    // Fixme ?
+  case TemplateArgument::Concept:
+    return getArgument().getAsPartiallyAppliedConcept()->getSourceRange();
+
   case TemplateArgument::TemplateExpansion:
     if (getTemplateQualifierLoc())
       return SourceRange(getTemplateQualifierLoc().getBeginLoc(),
@@ -662,6 +754,16 @@ static const T &DiagTemplateArg(const T &DB, const TemplateArgument &Arg) {
   case TemplateArgument::TemplateExpansion:
     return DB << Arg.getAsTemplateOrTemplatePattern() << "...";
 
+  case TemplateArgument::Concept:
+    return DB << *Arg.getAsPartiallyAppliedConcept();
+
+  case TemplateArgument::Universal:
+    return DB << *Arg.getAsUniversalTemplateParameterName();
+
+  case TemplateArgument::UniversalExpansion:
+    return DB << *Arg.getAsUniversalTemplateParameterOrPattern() << "...";
+    ;
+
   case TemplateArgument::Expression: {
     // This shouldn't actually ever happen, so it's okay that we're
     // regurgitating an expression here.
@@ -706,6 +808,17 @@ clang::TemplateArgumentLocInfo::TemplateArgumentLocInfo(
   Pointer = Template;
 }
 
+clang::TemplateArgumentLocInfo::TemplateArgumentLocInfo(
+    ASTContext &Ctx, UniversalTemplateParameterName *Param,
+    SourceLocation EllipsisLoc) {
+
+  UniversalTemplateArgLocInfo *Universal =
+      new (Ctx) UniversalTemplateArgLocInfo;
+  Universal->EllipsisLoc = EllipsisLoc;
+  Universal->Name = Param;
+  Pointer = Universal;
+}
+
 const ASTTemplateArgumentListInfo *
 ASTTemplateArgumentListInfo::Create(const ASTContext &C,
                                     const TemplateArgumentListInfo &List) {
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 3c51c74647182..c1bd94a34e28d 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -1237,6 +1237,23 @@ void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
   dumpBareTemplateName(TA.getAsTemplateOrTemplatePattern());
 }
 
+void TextNodeDumper::VisitConceptTemplateArgument(const TemplateArgument &TA) {
+  OS << " concept ";
+  OS << TA.getAsPartiallyAppliedConcept()->getConceptNameInfo().getName();
+}
+
+void TextNodeDumper::VisitUniversalTemplateArgument(
+    const TemplateArgument &TA) {
+  OS << " universal ";
+  OS << TA.getAsUniversalTemplateParameterName()->getDecl()->getDeclName();
+}
+
+void TextNodeDumper::VisitUniversalExpansionTemplateArgument(
+    const TemplateArgument &TA) {
+  OS << " universal expansion ";
+  OS << TA.getAsUniversalTemplateParameterName()->getDecl()->getDeclName();
+}
+
 void TextNodeDumper::VisitExpressionTemplateArgument(
     const TemplateArgument &TA) {
   OS << " expr";
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index a55e6c8bf0261..1f1139e65d3af 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -5069,7 +5069,7 @@ void clang::FixedPointValueToString(SmallVectorImpl<char> &Str,
 
 AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
                    TypeDependence ExtraDependence, QualType Canon,
-                   ConceptDecl *TypeConstraintConcept,
+                   TemplateDecl *TypeConstraintConcept,
                    ArrayRef<TemplateArgument> TypeConstraintArgs)
     : DeducedType(Auto, DeducedAsType, ExtraDependence, Canon) {
   AutoTypeBits.Keyword = llvm::to_underlying(Keyword);
@@ -5077,6 +5077,11 @@ AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
   this->TypeConstraintConcept = TypeConstraintConcept;
   assert(TypeConstraintConcept || AutoTypeBits.NumArgs == 0);
   if (TypeConstraintConcept) {
+    if (TemplateTemplateParmDecl *TTP =
+            dyn_cast<TemplateTemplateParmDecl>(TypeConstraintConcept)) {
+      addDependence(TypeDependence::DependentInstantiation);
+    }
+
     auto *ArgBuffer =
         const_cast<TemplateArgument *>(getTypeConstraintArguments().data());
     for (const TemplateArgument &Arg : TypeConstraintArgs) {
@@ -5091,9 +5096,9 @@ AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
 }
 
 void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
-                      QualType Deduced, AutoTypeKeyword Keyword,
-                      bool IsDependent, ConceptDecl *CD,
-                      ArrayRef<TemplateArgument> Arguments) {
+                       QualType Deduced, AutoTypeKeyword Keyword,
+                       bool IsDependent, TemplateDecl *CD,
+                       ArrayRef<TemplateArgument> Arguments) {
   ID.AddPointer(Deduced.getAsOpaquePtr());
   ID.AddInteger((unsigned)Keyword);
   ID.AddBoolean(IsDependent);
diff --git a/clang/lib/AST/UniversalTemplateParameterName.cpp b/clang/lib/AST/UniversalTemplateParameterName.cpp
new file mode 100644
index 0000000000000..2b7e572bddc3c
--- /dev/null
+++ b/clang/lib/AST/UniversalTemplateParameterName.cpp
@@ -0,0 +1,64 @@
+//===- TemplateName.cpp - C++ Template Name Representation ----------------===//
+//
+// 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 defines the TemplateName interface and subclasses.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/UniversalTemplateParameterName.h"
+#include "clang/AST/DeclTemplate.h"
+#include <cassert>
+#include <optional>
+#include <string>
+
+using namespace clang;
+
+UniversalTemplateParameterName::UniversalTemplateParameterName(
+    SourceLocation Loc, DeclarationNameInfo Name,
+    UniversalTemplateParmDecl *Param)
+    : Loc(Loc), Name(Name), Param(Param) {}
+
+bool UniversalTemplateParameterName::containsUnexpandedParameterPack() const {
+  return Param->isTemplateParameterPack();
+}
+
+void UniversalTemplateParameterName::Profile(
+    llvm::FoldingSetNodeID &ID, DeclarationNameInfo Name,
+    const UniversalTemplateParmDecl *Decl, const ASTContext &Context) {
+  ID.AddPointer(Decl);
+}
+
+void UniversalTemplateParameterName::print(raw_ostream &OS,
+                                           const PrintingPolicy &Policy) const {
+  Name.printName(OS, Policy);
+}
+
+const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+                                             UniversalTemplateParameterName N) {
+  std::string NameStr;
+  llvm::raw_string_ostream OS(NameStr);
+  LangOptions LO;
+  LO.CPlusPlus = true;
+  LO.Bool = true;
+  OS << '\'';
+  N.print(OS, PrintingPolicy(LO));
+  OS << '\'';
+  OS.flush();
+  return DB << NameStr;
+}
+
+void UniversalTemplateParameterName::dump(raw_ostream &OS) const {
+  LangOptions LO;
+  LO.CPlusPlus = true;
+  LO.Bool = true;
+  print(OS, PrintingPolicy(LO));
+}
+
+LLVM_DUMP_METHOD void UniversalTemplateParameterName::dump() const {
+  dump(llvm::errs());
+}
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 2d2c280941bd6..8597304dbd3c8 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -5532,6 +5532,8 @@ bool CGDebugInfo::HasReconstitutableArgs(
     ArrayRef<TemplateArgument> Args) const {
   return llvm::all_of(Args, [&](const TemplateArgument &TA) {
     switch (TA.getKind()) {
+    case TemplateArgument::Concept:
+      return false;
     case TemplateArgument::Template:
       // Easy to reconstitute - the value of the parameter in the debug
       // info is the string name of the template. The template name
@@ -5602,7 +5604,6 @@ std::string CGDebugInfo::GetName(const Decl *D, bool Qualified) const {
   } else if (auto *VD = dyn_cast<VarDecl>(ND)) {
     Args = GetTemplateArgs(VD);
   }
-
   // A conversion operator presents complications/ambiguity if there's a
   // conversion to class template that is itself a template, eg:
   // template<typename T>
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index a04eed9873c0d..9dc75db4ae57f 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -2677,7 +2677,8 @@ bool Parser::ParseAsmAttributesAfterDeclarator(Declarator &D) {
 ///
 Decl *Parser::ParseDeclarationAfterDeclarator(
     Declarator &D, const ParsedTemplateInfo &TemplateInfo) {
-  if (ParseAsmAttributesAfterDeclarator(D))
+
+    if (ParseAsmAttributesAfterDeclarator(D))
     return nullptr;
 
   return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo);
@@ -3541,6 +3542,8 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
       case Sema::NC_TypeTemplate:
       case Sema::NC_UndeclaredNonType:
       case Sema::NC_UndeclaredTemplate:
+      case Sema::NC_Concept:
+      case Sema::NC_UniversalTemplateParam:
         // Not a previously-declared non-type entity.
         MightBeDeclarator = false;
         break;
@@ -3551,7 +3554,6 @@ Parser::DiagnoseMissingSemiAfterTagDefinition(DeclSpec &DS, AccessSpecifier AS,
       case Sema::NC_OverloadSet:
       case Sema::NC_VarTemplate:
       case Sema::NC_FunctionTemplate:
-      case Sema::NC_Concept:
         // Might be a redeclaration of a prior entity.
         break;
       }
diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp
index de29652abbfd9..f38bef2e713aa 100644
--- a/clang/lib/Parse/ParseTemplate.cpp
+++ b/clang/lib/Parse/ParseTemplate.cpp
@@ -13,6 +13,8 @@
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
@@ -588,6 +590,9 @@ NamedDecl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
     llvm_unreachable("template param classification can't be ambiguous");
   }
 
+  if (isUniversalTemplateParameterIntroducer())
+    return ParseUniversalTemplateParameter(Depth, Position);
+
   if (Tok.is(tok::kw_template))
     return ParseTemplateTemplateParameter(Depth, Position);
 
@@ -597,6 +602,14 @@ NamedDecl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
   return ParseNonTypeTemplateParameter(Depth, Position);
 }
 
+bool Parser::isUniversalTemplateParameterIntroducer() {
+  if (!Ident_universal)
+    Ident_universal = &PP.getIdentifierTable().get("universal");
+  return Tok.is(tok::identifier) &&
+         Tok.getIdentifierInfo() == Ident_universal &&
+         NextToken().is(tok::kw_template);
+}
+
 /// Check whether the current token is a template-id annotation denoting a
 /// type-constraint.
 bool Parser::isTypeConstraintAnnotation() {
@@ -818,41 +831,58 @@ NamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth,
     }
   }
 
+  TemplateNameKind Kind = TemplateNameKind::TNK_Non_template;
+  SourceLocation NameLoc;
+  IdentifierInfo *ParamName = nullptr;
+  SourceLocation EllipsisLoc;
+  bool TypenameKeyword = false;
+
+  if (TryConsumeToken(tok::kw_class)) {
+    Kind = TemplateNameKind::TNK_Type_template;
+  } else {
+
   // Provide an ExtWarn if the C++1z feature of using 'typename' here is used.
   // Generate a meaningful error if the user forgot to put class before the
   // identifier, comma, or greater. Provide a fixit if the identifier, comma,
   // or greater appear immediately or after 'struct'. In the latter case,
   // replace the keyword with 'class'.
-  bool TypenameKeyword = false;
-  if (!TryConsumeToken(tok::kw_class)) {
     bool Replace = Tok.isOneOf(tok::kw_typename, tok::kw_struct);
     const Token &Next = Tok.is(tok::kw_struct) ? NextToken() : Tok;
     if (Tok.is(tok::kw_typename)) {
       TypenameKeyword = true;
+      Kind = TemplateNameKind::TNK_Type_template;
       Diag(Tok.getLocation(),
            getLangOpts().CPlusPlus17
                ? diag::warn_cxx14_compat_template_template_param_typename
                : diag::ext_template_template_param_typename)
-        << (!getLangOpts().CPlusPlus17
-                ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
-                : FixItHint());
+          << (!getLangOpts().CPlusPlus17
+                  ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
+                  : FixItHint());
+      Kind = TemplateNameKind::TNK_Type_template;
+    } else if (TryConsumeToken(tok::kw_concept)) {
+      Kind = TemplateNameKind::TNK_Concept_template;
+    } else if (TryConsumeToken(tok::kw_auto)) {
+      Kind = TemplateNameKind::TNK_Var_template;
     } else if (Next.isOneOf(tok::identifier, tok::comma, tok::greater,
                             tok::greatergreater, tok::ellipsis)) {
+      // Provide a fixit if the identifier, comma,
+      // or greater appear immediately or after 'struct'. In the latter case,
+      // replace the keyword with 'class'.
       Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
           << getLangOpts().CPlusPlus17
           << (Replace
                   ? FixItHint::CreateReplacement(Tok.getLocation(), "class")
                   : FixItHint::CreateInsertion(Tok.getLocation(), "class "));
-    } else
-      Diag(Tok.getLocation(), diag::err_class_on_template_template_param)
-          << getLangOpts().CPlusPlus17;
-
+    }
     if (Replace)
       ConsumeToken();
   }
 
+  if(!getLangOpts().CPlusPlus23 && Kind != TemplateNameKind::TNK_Type_template) {
+      // Diag older language mods
+  }
+
   // Parse the ellipsis, if given.
-  SourceLocation EllipsisLoc;
   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
     Diag(EllipsisLoc,
          getLangOpts().CPlusPlus11
@@ -860,8 +890,7 @@ NamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth,
            : diag::ext_variadic_templates);
 
   // Get the identifier, if given.
-  SourceLocation NameLoc = Tok.getLocation();
-  IdentifierInfo *ParamName = nullptr;
+  NameLoc = Tok.getLocation();
   if (Tok.is(tok::identifier)) {
     ParamName = Tok.getIdentifierInfo();
     ConsumeToken();
@@ -899,8 +928,35 @@ NamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth,
   }
 
   return Actions.ActOnTemplateTemplateParameter(
-      getCurScope(), TemplateLoc, ParamList, TypenameKeyword, EllipsisLoc,
-      ParamName, NameLoc, Depth, Position, EqualLoc, DefaultArg);
+      getCurScope(), TemplateLoc, Kind, TypenameKeyword, ParamList, EllipsisLoc, ParamName,
+      NameLoc, Depth, Position, EqualLoc, DefaultArg);
+}
+
+/// ParseUniversalTemplateParameter - Handle the parsing of universal
+/// template parameters (e.g., in "template<any template Size> class foo;").
+///
+///       template-parameter:
+///         ...
+///
+NamedDecl *Parser::ParseUniversalTemplateParameter(unsigned Depth,
+                                                   unsigned Position) {
+  assert(isUniversalTemplateParameterIntroducer() &&
+         "Expected universal template parameter");
+  SourceLocation NameLoc;
+  IdentifierInfo *ParamName = nullptr;
+  SourceLocation StartLoc = ConsumeToken();
+  ConsumeToken();
+
+  SourceLocation EllipsisLoc;
+  TryConsumeToken(tok::ellipsis, EllipsisLoc);
+
+  if (Tok.is(tok::identifier)) {
+    ParamName = Tok.getIdentifierInfo();
+    NameLoc = ConsumeToken();
+  }
+  return Actions.ActOnUniversalTemplateParameter(getCurScope(), StartLoc,
+                                                 EllipsisLoc, ParamName,
+                                                 NameLoc, Depth, Position);
 }
 
 /// ParseNonTypeTemplateParameter - Handle the parsing of non-type
@@ -1397,9 +1453,11 @@ static bool isEndOfTemplateArgument(Token Tok) {
 /// Parse a C++ template template argument.
 ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
   if (!Tok.is(tok::identifier) && !Tok.is(tok::coloncolon) &&
-      !Tok.is(tok::annot_cxxscope))
+      !Tok.is(tok::annot_cxxscope) && !Tok.is(tok::annot_template_id) &&
+      !Tok.is(tok::annot_non_type))
     return ParsedTemplateArgument();
 
+
   // C++0x [temp.arg.template]p1:
   //   A template-argument for a template template-parameter shall be the name
   //   of a class template or an alias template, expressed as id-expression.
@@ -1441,12 +1499,30 @@ ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
                                     /*EnteringContext=*/false, Template))
         Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
     }
-  } else if (Tok.is(tok::identifier)) {
+  } else if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)
+            ||Tok.is(tok::annot_non_type)
+             ) {
     // We may have a (non-dependent) template name.
     TemplateTy Template;
     UnqualifiedId Name;
-    Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
-    ConsumeToken(); // the identifier
+    if(Tok.is(tok::annot_non_type))
+    {
+         NamedDecl *ND = getNonTypeAnnotation(Tok);
+         if(!isa<VarTemplateDecl>(ND))
+             return Result;
+         Name.setIdentifier(ND->getIdentifier(), Tok.getLocation());
+         ConsumeAnnotationToken();
+    }
+    else if(Tok.is(tok::annot_template_id)) {
+         TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
+         if(TemplateId->LAngleLoc.isValid())
+             return Result;
+         Name.setIdentifier(TemplateId->Name, Tok.getLocation());
+         ConsumeAnnotationToken();
+    } else {
+      Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
+      ConsumeToken(); // the identifier
+    }
 
     TryConsumeToken(tok::ellipsis, EllipsisLoc);
 
@@ -1457,7 +1533,10 @@ ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
           /*hasTemplateKeyword=*/false, Name,
           /*ObjectType=*/nullptr,
           /*EnteringContext=*/false, Template, MemberOfUnknownSpecialization);
-      if (TNK == TNK_Dependent_template_name || TNK == TNK_Type_template) {
+      if (TNK == TNK_Dependent_template_name || TNK == TNK_Type_template
+            || TNK == TNK_Var_template
+            || TNK == TNK_Concept_template
+              ) {
         // We have an id-expression that refers to a class template or
         // (C++0x) alias template.
         Result = ParsedTemplateArgument(SS, Template, Name.StartLocation);
@@ -1472,6 +1551,60 @@ ParsedTemplateArgument Parser::ParseTemplateTemplateArgument() {
   return Result;
 }
 
+///  partially-applied-concept:
+///    concept id-dexpression < arguments >
+ParsedTemplateArgument Parser::ParsePartiallyAppliedConceptTemplateArgument() {
+  if (Tok.isNot(tok::kw_concept))
+    return {};
+  SourceLocation ConceptLoc = ConsumeToken();
+  CXXScopeSpec SS; // nested-name-specifier, if present
+  ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
+                                 /*ObjectHasErrors=*/false,
+                                 /*EnteringContext=*/false);
+  ParsedTemplateArgument Result;
+  if (Tok.is(tok::annot_template_id)) {
+    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
+    ConsumeAnnotationToken();
+    PartiallyAppliedConcept *C = Actions.ActOnPartiallyAppliedConcept(
+        getCurScope(), SS, ConceptLoc, TemplateId);
+    if (!C)
+      return {};
+    Result = ParsedTemplateArgument(C, ConceptLoc);
+    return Result;
+  }
+  return {};
+}
+
+ParsedTemplateArgument Parser::ParseUniversalTemplateParamNameArgument() {
+  if (!Tok.isOneOf(tok::identifier, tok::annot_universal))
+    return ParsedTemplateArgument();
+
+  UnqualifiedId Name;
+  SourceLocation EllipsisLoc;
+  if (Tok.is(tok::annot_universal)) {
+    NamedDecl *ND = getNonTypeAnnotation(Tok);
+    Name.setIdentifier(ND->getIdentifier(), Tok.getLocation());
+    ConsumeAnnotationToken();
+  } else {
+    Name.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
+    ConsumeToken();
+  }
+  TryConsumeToken(tok::ellipsis, EllipsisLoc);
+
+  UniversalTemplateParamNameTy Universal;
+  if (Actions.ActOnUniversalTemplateParameterName(
+          getCurScope(), Name, /*EnteringContext=*/false, Universal) ||
+      !Universal)
+    return {};
+  ParsedTemplateArgument Result =
+      ParsedTemplateArgument(Universal, Name.getBeginLoc());
+  // If this is a pack expansion, build it as such.
+  if (EllipsisLoc.isValid() && !Result.isInvalid())
+    Result = Actions.ActOnPackExpansion(Result, EllipsisLoc);
+
+  return Result;
+}
+
 /// ParseTemplateArgument - Parse a C++ template argument (C++ [temp.names]).
 ///
 ///       template-argument: [C++ 14.2]
@@ -1505,30 +1638,55 @@ ParsedTemplateArgument Parser::ParseTemplateArgument() {
   {
     TentativeParsingAction TPA(*this);
 
-    ParsedTemplateArgument TemplateTemplateArgument
-      = ParseTemplateTemplateArgument();
+    ParsedTemplateArgument TemplateTemplateArgument = ParseTemplateTemplateArgument();
     if (!TemplateTemplateArgument.isInvalid()) {
       TPA.Commit();
       return TemplateTemplateArgument;
     }
+    // Revert this tentative parse to parse a non-type template argument.
+    TPA.Revert();
+  }
 
+  // Try to parse a template template argument.
+  {
+    TentativeParsingAction TPA(*this);
+
+    ParsedTemplateArgument UniversalTemplateParamNameArg =
+        ParseUniversalTemplateParamNameArgument();
+    if (!UniversalTemplateParamNameArg.isInvalid()) {
+      TPA.Commit();
+      return UniversalTemplateParamNameArg;
+    }
     // Revert this tentative parse to parse a non-type template argument.
     TPA.Revert();
   }
 
-  // Parse a non-type template argument.
-  ExprResult ExprArg;
-  SourceLocation Loc = Tok.getLocation();
-  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
-    ExprArg = ParseBraceInitializer();
-  else
-    ExprArg = ParseConstantExpressionInExprEvalContext(MaybeTypeCast);
-  if (ExprArg.isInvalid() || !ExprArg.get()) {
-    return ParsedTemplateArgument();
+  {
+    ParsedTemplateArgument Concept =
+        ParsePartiallyAppliedConceptTemplateArgument();
+    if (!Concept.isInvalid())
+      return Concept;
   }
 
-  return ParsedTemplateArgument(ParsedTemplateArgument::NonType,
-                                ExprArg.get(), Loc);
+  {
+      TentativeParsingAction TPA(*this);
+      // Parse a non-type template argument.
+      SourceLocation Loc = Tok.getLocation();
+      ExprResult ExprArg;
+      if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))
+        ExprArg = ParseBraceInitializer();
+      else
+        ExprArg = ParseConstantExpressionInExprEvalContext(MaybeTypeCast);
+      if (!ExprArg.isInvalid() && ExprArg.get()) {
+          TPA.Commit();
+          return ParsedTemplateArgument(ParsedTemplateArgument::NonType,
+                                        ExprArg.get(), Loc);
+      }
+      // Revert this tentative parse to parse a template template argument.
+      TPA.Revert();
+   }
+
+  return ParsedTemplateArgument{};
 }
 
 /// ParseTemplateArgumentList - Parse a C++ template-argument-list
diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp
index 9f6b4f6118ede..69eac6d785615 100644
--- a/clang/lib/Parse/ParseTentative.cpp
+++ b/clang/lib/Parse/ParseTentative.cpp
@@ -1707,7 +1707,7 @@ Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename,
               // If we annotated then the current token should not still be ::
               // FIXME we may want to also check for tok::annot_typename but
               // currently don't have a test case.
-              if (Tok.isNot(tok::annot_cxxscope))
+              if (Tok.isNot(tok::annot_cxxscope) && Tok.isNot(tok::identifier))
                 break;
             }
 
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 04c2f1d380bc4..683b322b18f1b 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -21,6 +21,7 @@
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaCodeCompletion.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TimeProfiler.h"
@@ -516,6 +517,7 @@ void Parser::Initialize() {
   Ident_GNU_final = nullptr;
   Ident_import = nullptr;
   Ident_module = nullptr;
+  Ident_universal = nullptr;
 
   Ident_super = &PP.getIdentifierTable().get("super");
 
@@ -1848,6 +1850,14 @@ Parser::TryAnnotateName(CorrectionCandidateCallback *CCC,
     // It's not something we know about. Leave it unannotated.
     break;
 
+  case Sema::NC_UniversalTemplateParam:
+    Tok.setKind(tok::annot_universal);
+    setNonTypeAnnotation(Tok, Classification.getUniversalTemplateDecl());
+    Tok.setLocation(NameLoc);
+    Tok.setAnnotationEndLoc(NameLoc);
+    PP.AnnotateCachedTokens(Tok);
+    return ANK_Success;
+
   case Sema::NC_Type: {
     if (TryAltiVecVectorToken())
       // vector has been found as a type id when altivec is enabled but
@@ -1922,25 +1932,26 @@ Parser::TryAnnotateName(CorrectionCandidateCallback *CCC,
       AnnotateScopeToken(SS, !WasScopeAnnotation);
     return ANK_Success;
 
-  case Sema::NC_TypeTemplate:
+  case Sema::NC_TypeTemplate: {
     if (Next.isNot(tok::less)) {
-      // This may be a type template being used as a template template argument.
+      // This may be a type or variable template being used as a template template argument.
       if (SS.isNotEmpty())
         AnnotateScopeToken(SS, !WasScopeAnnotation);
       return ANK_TemplateName;
     }
     [[fallthrough]];
-  case Sema::NC_Concept:
+  }
   case Sema::NC_VarTemplate:
+  case Sema::NC_Concept:
   case Sema::NC_FunctionTemplate:
   case Sema::NC_UndeclaredTemplate: {
     bool IsConceptName = Classification.getKind() == Sema::NC_Concept;
     // We have a template name followed by '<'. Consume the identifier token so
     // we reach the '<' and annotate it.
-    if (Next.is(tok::less))
-      ConsumeToken();
     UnqualifiedId Id;
     Id.setIdentifier(Name, NameLoc);
+    if (Next.is(tok::less))
+      ConsumeToken();
     if (AnnotateTemplateIdToken(
             TemplateTy::make(Classification.getTemplateName()),
             Classification.getTemplateNameKind(), SS, SourceLocation(), Id,
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index af1dc21594da8..8bc6e2fc875f7 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -34,6 +34,7 @@
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
+#include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
@@ -3389,7 +3390,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
 }
 
 void Sema::CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc) {
-  if (ConceptDecl *Decl = AutoT->getTypeConstraintConcept()) {
+  if (TemplateDecl *Decl = AutoT->getTypeConstraintConcept()) {
     DiagnoseUseOfDecl(Decl, Loc);
   }
 }
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 1bf0e800a3622..30e04bbce6477 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -59,6 +59,8 @@
 #include "llvm/ADT/STLForwardCompat.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Triple.h"
 #include <algorithm>
 #include <cstring>
@@ -1183,6 +1185,9 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
         TemplateName(cast<TemplateDecl>(FirstDecl)));
   }
 
+  if (auto *UTP = dyn_cast<UniversalTemplateParmDecl>(FirstDecl))
+    return NameClassification::Universal(UTP);
+
   if (auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(FirstDecl)) {
     (void)DiagnoseUseOfDecl(EmptyD, NameLoc);
     return NameClassification::Error();
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 66df9c969256a..f4d0dfb8a5f2d 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -2869,9 +2869,10 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
     // in BuildTemplateIdExpr().
     // The single lookup result must be a variable template declaration.
     if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId && Id.TemplateId &&
-        Id.TemplateId->Kind == TNK_Var_template) {
-      assert(R.getAsSingle<VarTemplateDecl>() &&
-             "There should only be one declaration found.");
+        (Id.TemplateId->Kind == TNK_Var_template ||  Id.TemplateId->Kind == TNK_Concept_template)) {
+      // TODO CORENTIN
+      // assert(R.getAsSingle<VarTemplateDecl>() &&
+      //       "There should only be one declaration found.");
     }
 
     return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
@@ -3233,6 +3234,13 @@ ExprResult Sema::BuildDeclarationNameExpr(
     return ExprError();
   }
 
+  // If we find a UTP, fail with a specific error
+  if (UniversalTemplateParmDecl *UTP = dyn_cast<UniversalTemplateParmDecl>(D)) {
+    Diag(Loc, diag::err_ref_utp) << D << SS.getRange();
+    Diag(D->getLocation(), diag::note_declared_at);
+    return ExprError();
+  }
+
   // Make sure that we're referring to a value.
   if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
     Diag(Loc, diag::err_ref_non_value) << D << SS.getRange();
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 4d11f2a43fcc6..61f2978894b47 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -12,6 +12,7 @@
 
 #include "CheckExprLifetime.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
@@ -3647,7 +3648,7 @@ ValueDecl *InitializedEntity::getDecl() const {
   case EK_ParenAggInitMember:
   case EK_Binding:
   case EK_TemplateParameter:
-    return Variable.VariableOrMember;
+    return cast<ValueDecl>(Variable.VariableOrMember);
 
   case EK_Parameter:
   case EK_Parameter_CF_Audited:
diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp
index ed5d44aa898f4..e08499bd0cc17 100644
--- a/clang/lib/Sema/SemaLookup.cpp
+++ b/clang/lib/Sema/SemaLookup.cpp
@@ -20,6 +20,7 @@
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/TemplateName.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
@@ -1690,6 +1691,9 @@ bool Sema::hasAcceptableDefaultArgument(
   if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D))
     return ::hasAcceptableDefaultArgument(*this, P, Modules, Kind);
 
+  if (isa<UniversalTemplateParmDecl>(D))
+    return false;
+
   return ::hasAcceptableDefaultArgument(
       *this, cast<TemplateTemplateParmDecl>(D), Modules, Kind);
 }
@@ -2946,6 +2950,9 @@ addAssociatedClassesAndNamespaces(AssociatedLookup &Result,
       break;
     }
 
+    case TemplateArgument::Concept:
+    case clang::TemplateArgument::Universal:
+    case clang::TemplateArgument::UniversalExpansion:
     case TemplateArgument::Declaration:
     case TemplateArgument::Integral:
     case TemplateArgument::Expression:
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index d304f322aced6..50683037c5379 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -17,6 +17,7 @@
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
@@ -6221,6 +6222,67 @@ static ExprResult BuildConvertedConstantExpression(Sema &S, Expr *From,
   return Result;
 }
 
+/// EvaluateConvertedConstantExpression - Evaluate an Expression
+/// That is a converted constant expression
+/// (which was built with BuildConvertedConstantExpression)
+static ExprResult EvaluateConvertedConstantExpression(
+    Sema &S, Expr *E, QualType T, APValue &Value, Sema::CCEKind CCE,
+    bool RequireInt, const APValue &PreNarrowingValue) {
+  ExprResult Result = E;
+
+  if (auto *CE = dyn_cast<ConstantExpr>(Result.get())) {
+    Value = CE->getAPValueResult();
+    return Result;
+  }
+
+  // Check the expression is a constant expression.
+  SmallVector<PartialDiagnosticAt, 8> Notes;
+  Expr::EvalResult Eval;
+  Eval.Diag = &Notes;
+
+  ConstantExprKind Kind;
+  if (CCE == Sema::CCEK_TemplateArg && T->isRecordType())
+    Kind = ConstantExprKind::ClassTemplateArgument;
+  else if (CCE == Sema::CCEK_TemplateArg)
+    Kind = ConstantExprKind::NonClassTemplateArgument;
+  else
+    Kind = ConstantExprKind::Normal;
+
+  if (!E->EvaluateAsConstantExpr(Eval, S.Context, Kind) ||
+      (RequireInt && !Eval.Val.isInt())) {
+    // The expression can't be folded, so we can't keep it at this position in
+    // the AST.
+    Result = ExprError();
+  } else {
+    Value = Eval.Val;
+
+    if (Notes.empty()) {
+      // It's a constant expression.
+      Expr *E = ConstantExpr::Create(S.Context, Result.get(), Value);
+      if (!PreNarrowingValue.isAbsent())
+        Value = std::move(PreNarrowingValue);
+      return E;
+    }
+  }
+
+  // It's not a constant expression. Produce an appropriate diagnostic.
+  if (Notes.size() == 1 &&
+      Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
+    S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
+  } else if (!Notes.empty() && Notes[0].second.getDiagID() ==
+                                   diag::note_constexpr_invalid_template_arg) {
+    Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
+    for (unsigned I = 0; I < Notes.size(); ++I)
+      S.Diag(Notes[I].first, Notes[I].second);
+  } else {
+    S.Diag(E->getBeginLoc(), diag::err_expr_not_cce)
+        << CCE << E->getSourceRange();
+    for (unsigned I = 0; I < Notes.size(); ++I)
+      S.Diag(Notes[I].first, Notes[I].second);
+  }
+  return ExprError();
+}
+
 /// CheckConvertedConstantExpression - Check that the expression From is a
 /// converted constant expression of type T, perform the conversion and produce
 /// the converted expression, per C++11 [expr.const]p3.
@@ -11560,9 +11622,10 @@ static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
                                  bool TakingCandidateAddress) {
   TemplateParameter Param = DeductionFailure.getTemplateParameter();
   NamedDecl *ParamD;
-  (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
-  (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
-  (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
+  (ParamD = Param.dyn_cast<TemplateTypeParmDecl *>()) ||
+      (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl *>()) ||
+      (ParamD = Param.dyn_cast<TemplateTemplateParmDecl *>()) ||
+      (ParamD = Param.dyn_cast<UniversalTemplateParmDecl *>());
   switch (DeductionFailure.getResult()) {
   case TemplateDeductionResult::Success:
     llvm_unreachable(
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 99423b01114cc..896cbf70018ae 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -17,8 +17,11 @@
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeVisitor.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/LangOptions.h"
@@ -33,6 +36,7 @@
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaCUDA.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
@@ -41,6 +45,7 @@
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Casting.h"
 
 #include <iterator>
 #include <optional>
@@ -309,6 +314,7 @@ TemplateNameKind Sema::isTemplateName(Scope *S,
              isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
              isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
       TemplateKind =
+          isa<TemplateTemplateParmDecl>(TD) ? dyn_cast<TemplateTemplateParmDecl>(TD)->kind() :
           isa<VarTemplateDecl>(TD) ? TNK_Var_template :
           isa<ConceptDecl>(TD) ? TNK_Concept_template :
           TNK_Type_template;
@@ -887,10 +893,20 @@ TemplateDecl *Sema::AdjustDeclIfTemplate(Decl *&D) {
 
 ParsedTemplateArgument ParsedTemplateArgument::getTemplatePackExpansion(
                                              SourceLocation EllipsisLoc) const {
-  assert(Kind == Template &&
-         "Only template template arguments can be pack expansions here");
-  assert(getAsTemplate().get().containsUnexpandedParameterPack() &&
-         "Template template argument pack expansion without packs");
+  assert((Kind == Template || Kind == Universal) &&
+         "Only template and universal template arguments can be pack "
+         "expansions here");
+
+  assert(Kind != Template ||
+         getAsTemplate().get().containsUnexpandedParameterPack() &&
+             "Template template argument pack expansion without packs");
+
+  assert(Kind != Universal ||
+         getAsUniversalTemplateParamName()
+                 .get()
+                 ->containsUnexpandedParameterPack() &&
+             "universal template argument pack expansion without packs");
+
   ParsedTemplateArgument Result(*this);
   Result.EllipsisLoc = EllipsisLoc;
   return Result;
@@ -925,8 +941,25 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef,
         Arg.getScopeSpec().getWithLocInContext(SemaRef.Context),
         Arg.getLocation(), Arg.getEllipsisLoc());
   }
+  case clang::ParsedTemplateArgument::PartiallyAppliedConcept: {
+    PartiallyAppliedConcept *C = Arg.getAsConcept();
+    TemplateArgument TArg(C);
+    return TemplateArgumentLoc(
+        SemaRef.Context, TArg,
+        Arg.getScopeSpec().getWithLocInContext(SemaRef.Context),
+        Arg.getLocation());
+  }
+  case clang::ParsedTemplateArgument::Universal: {
+    UniversalTemplateParamNameTy U = Arg.getAsUniversalTemplateParamName();
+    TemplateArgument TArg;
+    if (Arg.getEllipsisLoc().isValid())
+      TArg = TemplateArgument(U.get(), std::optional<unsigned int>());
+    else
+      TArg = TemplateArgument(U.get());
+    return TemplateArgumentLoc(SemaRef.Context, TArg, U.get(),
+                               Arg.getEllipsisLoc());
+  }
   }
-
   llvm_unreachable("Unhandled parsed template argument");
 }
 
@@ -1068,12 +1101,27 @@ makeTemplateArgumentListInfo(Sema &S, TemplateIdAnnotation &TemplateId) {
 bool Sema::CheckTypeConstraint(TemplateIdAnnotation *TypeConstr) {
 
   TemplateName TN = TypeConstr->Template.get();
-  ConceptDecl *CD = cast<ConceptDecl>(TN.getAsTemplateDecl());
+  NamedDecl *CD = nullptr;
+  bool IsTypeConcept = false;
+  bool RequiresArguments = false;
+  if (TemplateTemplateParmDecl *TTP =
+          llvm::dyn_cast<TemplateTemplateParmDecl>(TN.getAsTemplateDecl())) {
+    IsTypeConcept = TTP->isTypeConceptTemplateParam();
+    RequiresArguments =
+        TTP->getTemplateParameters()->getMinRequiredArguments() > 1;
+    CD = TTP;
+  } else {
+    CD = TN.getAsTemplateDecl();
+    IsTypeConcept = cast<ConceptDecl>(CD)->isTypeConcept();
+    RequiresArguments = cast<ConceptDecl>(CD)
+                            ->getTemplateParameters()
+                            ->getMinRequiredArguments() > 1;
+  }
 
   // C++2a [temp.param]p4:
   //     [...] The concept designated by a type-constraint shall be a type
   //     concept ([temp.concept]).
-  if (!CD->isTypeConcept()) {
+  if (!IsTypeConcept) {
     Diag(TypeConstr->TemplateNameLoc,
          diag::err_type_constraint_non_type_concept);
     return true;
@@ -1084,8 +1132,7 @@ bool Sema::CheckTypeConstraint(TemplateIdAnnotation *TypeConstr) {
 
   bool WereArgsSpecified = TypeConstr->LAngleLoc.isValid();
 
-  if (!WereArgsSpecified &&
-      CD->getTemplateParameters()->getMinRequiredArguments() > 1) {
+  if (!WereArgsSpecified && RequiresArguments) {
     Diag(TypeConstr->TemplateNameLoc,
          diag::err_type_constraint_missing_arguments)
         << CD;
@@ -1112,7 +1159,7 @@ bool Sema::BuildTypeConstraint(const CXXScopeSpec &SS,
     return true;
 
   TemplateName TN = TypeConstr->Template.get();
-  ConceptDecl *CD = cast<ConceptDecl>(TN.getAsTemplateDecl());
+  TemplateDecl *CD = cast<TemplateDecl>(TN.getAsTemplateDecl());
   UsingShadowDecl *USD = TN.getAsUsingShadowDecl();
 
   DeclarationNameInfo ConceptName(DeclarationName(TypeConstr->Name),
@@ -1140,10 +1187,10 @@ bool Sema::BuildTypeConstraint(const CXXScopeSpec &SS,
 template <typename ArgumentLocAppender>
 static ExprResult formImmediatelyDeclaredConstraint(
     Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo,
-    ConceptDecl *NamedConcept, NamedDecl *FoundDecl, SourceLocation LAngleLoc,
-    SourceLocation RAngleLoc, QualType ConstrainedType,
-    SourceLocation ParamNameLoc, ArgumentLocAppender Appender,
-    SourceLocation EllipsisLoc) {
+    NamedDecl *NamedConcept,  NamedDecl *FoundDecl,
+    SourceLocation LAngleLoc, SourceLocation RAngleLoc,
+    QualType ConstrainedType, SourceLocation ParamNameLoc,
+    ArgumentLocAppender Appender, SourceLocation EllipsisLoc) {
 
   TemplateArgumentListInfo ConstraintArgs;
   ConstraintArgs.addArgument(
@@ -1159,12 +1206,32 @@ static ExprResult formImmediatelyDeclaredConstraint(
   //     constraint of T. [...]
   CXXScopeSpec SS;
   SS.Adopt(NS);
-  ExprResult ImmediatelyDeclaredConstraint = S.CheckConceptTemplateId(
-      SS, /*TemplateKWLoc=*/SourceLocation(), NameInfo,
-      /*FoundDecl=*/FoundDecl ? FoundDecl : NamedConcept, NamedConcept,
-      &ConstraintArgs);
-  if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
-    return ImmediatelyDeclaredConstraint;
+  ExprResult ImmediatelyDeclaredConstraint;
+  if (auto *CD = dyn_cast<ConceptDecl>(NamedConcept)) {
+    ImmediatelyDeclaredConstraint = S.CheckConceptTemplateId(
+        SS, /*TemplateKWLoc=*/SourceLocation(), NameInfo,
+        // /*FoundDecl=*/FoundDecl ? FoundDecl : NamedConcept,
+        NamedConcept,
+        CD, &ConstraintArgs);
+    if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
+      return ImmediatelyDeclaredConstraint;
+  }
+  // We have a template template parameter
+  else {
+    auto *CDT = dyn_cast<TemplateTemplateParmDecl>(NamedConcept);
+    ImmediatelyDeclaredConstraint = S.CheckVarOrConceptTemplateTemplateId(
+        SS, NameInfo, CDT, SourceLocation(), &ConstraintArgs);
+    if (ImmediatelyDeclaredConstraint.isInvalid())
+      return ImmediatelyDeclaredConstraint;
+    UnresolvedSet<1> R;
+    R.addDecl(CDT);
+    ImmediatelyDeclaredConstraint = UnresolvedLookupExpr::Create(
+        S.getASTContext(), nullptr, SS.getWithLocInContext(S.getASTContext()),
+        SourceLocation(), NameInfo, false, &ConstraintArgs, R.begin(), R.end(), /*KnownDependent=*/false,
+                                                                                /*KnownInstantiationDependent=*/false);
+    if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
+      return ImmediatelyDeclaredConstraint;
+  }
 
   // C++2a [temp.param]p4:
   //     [...] If T is not a pack, then E is E', otherwise E is (E' && ...).
@@ -1188,7 +1255,7 @@ static ExprResult formImmediatelyDeclaredConstraint(
 
 bool Sema::AttachTypeConstraint(NestedNameSpecifierLoc NS,
                                 DeclarationNameInfo NameInfo,
-                                ConceptDecl *NamedConcept, NamedDecl *FoundDecl,
+                                TemplateDecl *NamedConcept, NamedDecl *FoundDecl,
                                 const TemplateArgumentListInfo *TemplateArgs,
                                 TemplateTypeParmDecl *ConstrainedParameter,
                                 SourceLocation EllipsisLoc) {
@@ -1574,11 +1641,16 @@ NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
   return Param;
 }
 
+/// ActOnTemplateTemplateParameter - Called when a C++ template template
+/// parameter (e.g. T in template <template \<typename> class T> class array)
+/// has been parsed. S is the current scope.
 NamedDecl *Sema::ActOnTemplateTemplateParameter(
-    Scope *S, SourceLocation TmpLoc, TemplateParameterList *Params,
-    bool Typename, SourceLocation EllipsisLoc, IdentifierInfo *Name,
-    SourceLocation NameLoc, unsigned Depth, unsigned Position,
-    SourceLocation EqualLoc, ParsedTemplateArgument Default) {
+    Scope *S, SourceLocation TmpLoc, TemplateNameKind Kind,
+    bool Typename,
+    TemplateParameterList *Params, SourceLocation EllipsisLoc,
+    IdentifierInfo *Name, SourceLocation NameLoc, unsigned Depth,
+    unsigned Position, SourceLocation EqualLoc,
+    ParsedTemplateArgument Default) {
   assert(S->isTemplateParamScope() &&
          "Template template parameter not in template parameter scope!");
 
@@ -1587,7 +1659,7 @@ NamedDecl *Sema::ActOnTemplateTemplateParameter(
   TemplateTemplateParmDecl *Param = TemplateTemplateParmDecl::Create(
       Context, Context.getTranslationUnitDecl(),
       NameLoc.isInvalid() ? TmpLoc : NameLoc, Depth, Position, IsParameterPack,
-      Name, Typename, Params);
+      Name, Kind, Typename, Params);
   Param->setAccess(AS_public);
 
   if (Param->isParameterPack())
@@ -1633,6 +1705,12 @@ NamedDecl *Sema::ActOnTemplateTemplateParameter(
       return Param;
     }
 
+    TemplateName Name = DefaultArg.getArgument().getAsTemplateOrTemplatePattern();
+    TemplateDecl *Template = Name.getAsTemplateDecl();
+    if(Template && !CheckDeclCompatibleWithTemplateTemplate(Template, Param, DefaultArg)) {
+      return Param;
+    }
+
     // Check for unexpanded parameter packs.
     if (DiagnoseUnexpandedParameterPack(DefaultArg.getLocation(),
                                         DefaultArg.getArgument().getAsTemplate(),
@@ -1645,6 +1723,36 @@ NamedDecl *Sema::ActOnTemplateTemplateParameter(
   return Param;
 }
 
+NamedDecl *Sema::ActOnUniversalTemplateParameter(
+    Scope *S, SourceLocation IntroducerLoc, SourceLocation EllipsisLoc,
+    IdentifierInfo *ParamName, SourceLocation NameLoc, unsigned Depth,
+    unsigned Position) {
+
+  assert(S->isTemplateParamScope() &&
+         "Template template parameter not in template parameter scope!");
+
+  // Construct the parameter object.
+  bool IsParameterPack = EllipsisLoc.isValid();
+  UniversalTemplateParmDecl *Param = UniversalTemplateParmDecl::Create(
+      Context, Context.getTranslationUnitDecl(),
+      NameLoc.isInvalid() ? IntroducerLoc : NameLoc, Depth, Position,
+      IsParameterPack, ParamName);
+  Param->setAccess(AS_public);
+
+  if (Param->isParameterPack())
+    if (auto *LSI = getEnclosingLambda())
+      LSI->LocalPacks.push_back(Param);
+
+  // If the template template parameter has a name, then link the identifier
+  // into the scope and lookup mechanisms.
+  if (ParamName) {
+    maybeDiagnoseTemplateParameterShadow(*this, S, NameLoc, ParamName);
+    S->AddDecl(Param);
+    IdResolver.AddDecl(Param);
+  }
+  return Param;
+}
+
 namespace {
 class ConstraintRefersToContainingTemplateChecker
     : public TreeTransform<ConstraintRefersToContainingTemplateChecker> {
@@ -2425,6 +2533,9 @@ bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
         PreviousDefaultArgLoc = NewNonTypeParm->getDefaultArgumentLoc();
       } else if (SawDefaultArgument)
         MissingDefaultArg = true;
+    } else if (UniversalTemplateParmDecl *UTP =
+                   dyn_cast<UniversalTemplateParmDecl>(*NewParam)) {
+
     } else {
       TemplateTemplateParmDecl *NewTemplateParm
         = cast<TemplateTemplateParmDecl>(*NewParam);
@@ -2644,6 +2755,18 @@ struct DependencyChecker : RecursiveASTVisitor<DependencyChecker> {
     return super::VisitDeclRefExpr(E);
   }
 
+  bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *ULE) {
+    if (ULE->isConceptReference() || ULE->isVarDeclReference()) {
+      if (auto *TTP = ULE->getTemplateTemplateDecl()) {
+        if (Matches(TTP->getDepth(), ULE->getExprLoc()))
+          return false;
+      }
+      for (auto &TLoc : ULE->template_arguments())
+        super::TraverseTemplateArgumentLoc(TLoc);
+    }
+    return super::VisitUnresolvedLookupExpr(ULE);
+  }
+
   bool VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
     return TraverseType(T->getReplacementType());
   }
@@ -3484,10 +3607,12 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
       return Context.getTemplateSpecializationType(Name,
                                                    TemplateArgs.arguments());
 
-    Diag(TemplateLoc, diag::err_template_id_not_a_type)
-      << Name;
-    NoteAllFoundTemplates(Name);
-    return QualType();
+    //if(isa<FunctionTemplateDecl>(Template)) {
+        Diag(TemplateLoc, diag::err_template_id_not_a_type)
+          << Name;
+        NoteAllFoundTemplates(Name);
+        return QualType();
+    //}
   }
 
   // Check that the template argument list is well-formed for this
@@ -3948,8 +4073,12 @@ static bool CheckTemplateSpecializationScope(Sema &S, NamedDecl *Specialized,
 
 static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D);
 
-static bool isTemplateArgumentTemplateParameter(
-    const TemplateArgument &Arg, unsigned Depth, unsigned Index) {
+static bool isTemplateArgumentTemplateParameter(const TemplateArgument &Arg,
+                                                NamedDecl *Param,
+                                                unsigned Depth,
+                                                unsigned Index) {
+  bool ParamIsUniversal = isa<UniversalTemplateParmDecl>(Param);
+
   switch (Arg.getKind()) {
   case TemplateArgument::Null:
   case TemplateArgument::NullPtr:
@@ -3961,6 +4090,8 @@ static bool isTemplateArgumentTemplateParameter(
     return false;
 
   case TemplateArgument::Type: {
+    if (ParamIsUniversal)
+      return false;
     QualType Type = Arg.getAsType();
     const TemplateTypeParmType *TPT =
         Arg.getAsType()->getAs<TemplateTypeParmType>();
@@ -3969,6 +4100,8 @@ static bool isTemplateArgumentTemplateParameter(
   }
 
   case TemplateArgument::Expression: {
+    if (ParamIsUniversal)
+      return false;
     DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr());
     if (!DRE || !DRE->getDecl())
       return false;
@@ -3976,8 +4109,9 @@ static bool isTemplateArgumentTemplateParameter(
         dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
     return NTTP && NTTP->getDepth() == Depth && NTTP->getIndex() == Index;
   }
-
   case TemplateArgument::Template:
+    if (ParamIsUniversal)
+      return false;
     const TemplateTemplateParmDecl *TTP =
         dyn_cast_or_null<TemplateTemplateParmDecl>(
             Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl());
@@ -4005,7 +4139,8 @@ static bool isSameAsPrimaryTemplate(TemplateParameterList *Params,
       Arg = Arg.pack_begin()->getPackExpansionPattern();
     }
 
-    if (!isTemplateArgumentTemplateParameter(Arg, Depth, I))
+    if (!isTemplateArgumentTemplateParameter(Arg, Params->getParam(I), Depth,
+                                             I))
       return false;
   }
 
@@ -4505,6 +4640,32 @@ ExprResult Sema::CheckVarTemplateId(
   return BuildDeclarationNameExpr(SS, NameInfo, Var, FoundD, TemplateArgs);
 }
 
+ExprResult
+Sema::CheckVarOrConceptTemplateTemplateId(const CXXScopeSpec &,
+                         const DeclarationNameInfo &,
+                         TemplateTemplateParmDecl *Template, SourceLocation TemplateLoc,
+                         const TemplateArgumentListInfo *TemplateArgs)
+{
+    assert(Template && "A variable template id without template?");
+
+    if(Template->kind() != TemplateNameKind::TNK_Var_template
+            && Template->kind() != TemplateNameKind::TNK_Concept_template)
+        return ExprResult();
+
+
+    // Check that the template argument list is well-formed for this template.
+    SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
+    if (CheckTemplateArgumentList(
+            Template, TemplateLoc,
+            const_cast<TemplateArgumentListInfo &>(*TemplateArgs),
+            /*DefaultArgs=*/{}, false,
+            SugaredConverted, CanonicalConverted, /*UpdateArgsWithConversion=*/true))
+      return true;
+
+    return ExprResult();
+}
+
+
 void Sema::diagnoseMissingTemplateArguments(TemplateName Name,
                                             SourceLocation Loc) {
   Diag(Loc, diag::err_template_missing_args)
@@ -4577,7 +4738,7 @@ ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      LookupResult &R,
                                      bool RequiresADL,
-                                 const TemplateArgumentListInfo *TemplateArgs) {
+                                     const TemplateArgumentListInfo *TemplateArgs) {
   // FIXME: Can we do any checking at this point? I guess we could check the
   // template arguments that we have against the template name, if the template
   // name refers to a single template. That's not a terribly common case,
@@ -4617,6 +4778,16 @@ ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                   R.getAsSingle<ConceptDecl>(), TemplateArgs);
   }
 
+  // In C++1y, check variable template ids.
+  if (R.getAsSingle<TemplateTemplateParmDecl>()) {
+    ExprResult Res = CheckVarOrConceptTemplateTemplateId(SS, R.getLookupNameInfo(),
+                                        R.getAsSingle<TemplateTemplateParmDecl>(),
+                                        TemplateKWLoc, TemplateArgs);
+    if (Res.isInvalid() || Res.isUsable())
+      return Res;
+    // Result is dependent. Carry on to build an UnresolvedLookupEpxr.
+  }
+
   // We don't want lookup warnings at this point.
   R.suppressDiagnostics();
 
@@ -4794,6 +4965,65 @@ TemplateNameKind Sema::ActOnTemplateName(Scope *S,
   return TNK_Non_template;
 }
 
+PartiallyAppliedConcept *Sema::BuildPartiallyAppliedConcept(
+    NestedNameSpecifierLoc NNS, SourceLocation ConceptKWLoc,
+    DeclarationNameInfo ConceptName, TemplateDecl *TD,
+    const TemplateArgumentListInfo &TemplateArgs) {
+
+  return PartiallyAppliedConcept::Create(getASTContext(), NNS, ConceptName,
+                                         ConceptKWLoc, TD, TD, TemplateArgs);
+}
+
+PartiallyAppliedConcept *
+Sema::ActOnPartiallyAppliedConcept(Scope *S, CXXScopeSpec &SS,
+                                   SourceLocation ConceptKWLoc,
+                                   TemplateIdAnnotation *TemplateId) {
+
+  if (TemplateId->isInvalid())
+    return nullptr;
+  TemplateName TN = TemplateId->Template.get();
+  if (TN.isNull())
+    return nullptr;
+  bool IsConcept = false;
+  TemplateDecl *TD = TN.getAsTemplateDecl();
+  if(!TD)
+    return nullptr;
+  if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
+    IsConcept = TTP->kind() == TNK_Concept_template;
+  else
+    IsConcept = isa<ConceptDecl>(TD);
+  if (!IsConcept) {
+    Diag(TemplateId->TemplateNameLoc, diag::err_partial_concept_valid_template);
+    return nullptr;
+  }
+
+  DeclarationNameInfo ConceptName(DeclarationName(TemplateId->Name),
+                                  TemplateId->TemplateNameLoc);
+  TemplateArgumentListInfo TemplateArgs =
+      makeTemplateArgumentListInfo(*this, *TemplateId);
+  NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+  return BuildPartiallyAppliedConcept(NNS, ConceptKWLoc, ConceptName, TD,
+                                      TemplateArgs);
+}
+
+bool Sema::ActOnUniversalTemplateParameterName(
+    Scope *S, const UnqualifiedId &Name, bool EnteringContext,
+    UniversalTemplateParamNameTy &Template) {
+
+  DeclarationNameInfo DNI = GetNameFromUnqualifiedId(Name);
+  LookupResult R(*this, DNI.getName(), Name.getBeginLoc(), LookupOrdinaryName);
+  LookupName(R, S);
+  if (!R.isSingleResult())
+    return true;
+  UniversalTemplateParmDecl *UTP = R.getAsSingle<UniversalTemplateParmDecl>();
+  if (!UTP)
+    return true;
+  Template = UniversalTemplateParamNameTy::make(
+      getASTContext().getUniversalTemplateParameterName(Name.getBeginLoc(), DNI,
+                                                        UTP));
+  return false;
+}
+
 bool Sema::CheckTemplateTypeArgument(
     TemplateTypeParmDecl *Param, TemplateArgumentLoc &AL,
     SmallVectorImpl<TemplateArgument> &SugaredConverted,
@@ -4820,6 +5050,13 @@ bool Sema::CheckTemplateTypeArgument(
     diagnoseMissingTemplateArguments(Name, SR.getEnd());
     return true;
   }
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion: {
+    ArgType = Context.DependentTy;
+    TSI = Context.getTrivialTypeSourceInfo(ArgType);
+    break;
+  }
+
   case TemplateArgument::Expression: {
     // We have a template type parameter but the template argument is an
     // expression; see if maybe it is missing the "typename" keyword.
@@ -4915,6 +5152,108 @@ bool Sema::CheckTemplateTypeArgument(
   return false;
 }
 
+bool Sema::CheckUniversalTemplateParameterArgument(
+    UniversalTemplateParmDecl *Param, TemplateArgumentLoc &AL,
+    SmallVectorImpl<TemplateArgument> &SugaredConverted,
+    SmallVectorImpl<TemplateArgument> &CanonicalConverted,
+    CheckTemplateArgumentKind CTAK) {
+
+  const TemplateArgument &Arg = AL.getArgument();
+
+  switch (Arg.getKind()) {
+  case TemplateArgument::Null:
+    llvm_unreachable("Should never see a NULL template argument here");
+    break;
+  case TemplateArgument::Pack:
+    llvm_unreachable("Caller must expand template argument packs");
+  case TemplateArgument::Type: {
+    QualType ArgType = Arg.getAsType();
+    TypeSourceInfo *TSI = AL.getTypeSourceInfo();
+    if (CheckTemplateArgument(TSI))
+      return true;
+    if (getLangOpts().ObjCAutoRefCount && ArgType->isObjCLifetimeType() &&
+        !ArgType.getObjCLifetime()) {
+      Qualifiers Qs;
+      Qs.setObjCLifetime(Qualifiers::OCL_Strong);
+      ArgType = Context.getQualifiedType(ArgType, Qs);
+    }
+    SugaredConverted.push_back(TemplateArgument(ArgType));
+    CanonicalConverted.push_back(
+        TemplateArgument(Context.getCanonicalType(ArgType)));
+    return false;
+  }
+  case TemplateArgument::Expression: {
+    Expr *E = Arg.getAsExpr();
+
+    // deduce a universal template param from a variable template parameter
+    if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E);
+        ULE && (ULE->isConceptReference() || ULE->isVarDeclReference())) {
+      TemplateArgument TA(ULE);
+      AL = TemplateArgumentLoc(TA, ULE);
+      SugaredConverted.push_back(TA);
+      CanonicalConverted.push_back(TA);
+      break;
+    }
+
+    // If we have an id-expression
+    // do not make any deduction yet, we will do that when we
+    // initialize a non-universal template argument.
+    // Only check that we have a constant expression
+    if (auto *DR = dyn_cast<DeclRefExpr>(E);
+        DR && CTAK == CheckTemplateArgumentKind::CTAK_Deduced) {
+      TemplateArgument TA(DR);
+      AL = TemplateArgumentLoc(TA, DR);
+      SugaredConverted.push_back(TA);
+      CanonicalConverted.push_back(TA);
+      break;
+    }
+
+    // For arbitrary expressions, use decltype(auto) semantics
+    TemplateArgument SugaredResult, CanonicalResult;
+    unsigned CurSFINAEErrors = NumSFINAEErrors;
+    QualType Type =
+        Context.getAutoType(QualType(), AutoTypeKeyword::DecltypeAuto, false);
+    ExprResult Res = CheckTemplateArgument(Param, Type, E, SugaredResult,
+                                           CanonicalResult, CTAK);
+    if (Res.isInvalid())
+      return true;
+    // If the current template argument causes an error, give up now.
+    if (CurSFINAEErrors < NumSFINAEErrors)
+      return true;
+
+    // If the resulting expression is new, then use it in place of the
+    // old expression in the template argument.
+    if (Res.get() != E) {
+      TemplateArgument TA(Res.get());
+      AL = TemplateArgumentLoc(TA, Res.get());
+    }
+
+    SugaredConverted.push_back(SugaredResult);
+    CanonicalConverted.push_back(CanonicalResult);
+    break;
+  }
+  case TemplateArgument::Concept:
+    // TODO check invalid
+  case TemplateArgument::Declaration:
+  case TemplateArgument::Integral:
+  case TemplateArgument::NullPtr:
+    // We've already checked this template argument, so just copy
+    // it to the list of converted arguments.
+    SugaredConverted.push_back(Arg);
+    CanonicalConverted.push_back(Context.getCanonicalTemplateArgument(Arg));
+    break;
+  case TemplateArgument::Template:
+  case TemplateArgument::TemplateExpansion:
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion:
+    // TODO check invalid
+    SugaredConverted.push_back(Arg);
+    CanonicalConverted.push_back(Context.getCanonicalTemplateArgument(Arg));
+    break;
+  }
+  return false;
+}
+
 /// Substitute template arguments into the default template argument for
 /// the given template type parameter.
 ///
@@ -5118,6 +5457,10 @@ TemplateArgumentLoc Sema::SubstDefaultTemplateArgumentIfAvailable(
     return Output;
   }
 
+  // universal template params do not have default args
+  if (isa<UniversalTemplateParmDecl>(Param))
+    return TemplateArgumentLoc();
+
   TemplateTemplateParmDecl *TempTempParm
     = cast<TemplateTemplateParmDecl>(Param);
   if (!hasReachableDefaultArgument(TempTempParm))
@@ -5178,6 +5521,7 @@ bool Sema::CheckTemplateArgument(
     SmallVectorImpl<TemplateArgument> &SugaredConverted,
     SmallVectorImpl<TemplateArgument> &CanonicalConverted,
     CheckTemplateArgumentKind CTAK) {
+
   // Check template type parameters.
   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
     return CheckTemplateTypeArgument(TTP, Arg, SugaredConverted,
@@ -5263,6 +5607,19 @@ bool Sema::CheckTemplateArgument(
           Context.getCanonicalTemplateArgument(Arg.getArgument()));
       break;
 
+    // TODO support non-type concepts
+    case TemplateArgument::Concept:
+      Diag(Arg.getLocation(), diag::err_template_arg_must_be_expr)
+          << Arg.getSourceRange();
+      Diag(Param->getLocation(), diag::note_template_param_here);
+      return true;
+
+    case TemplateArgument::Universal:
+      SugaredConverted.push_back(Arg.getArgument());
+      CanonicalConverted.push_back(
+          Context.getCanonicalTemplateArgument(Arg.getArgument()));
+      break;
+
     case TemplateArgument::Template:
     case TemplateArgument::TemplateExpansion:
       // We were given a template template argument. It may not be ill-formed;
@@ -5336,7 +5693,6 @@ bool Sema::CheckTemplateArgument(
       NoteTemplateParameterLocation(*Param);
       return true;
     }
-
     case TemplateArgument::Pack:
       llvm_unreachable("Caller must expand template argument packs");
     }
@@ -5344,6 +5700,10 @@ bool Sema::CheckTemplateArgument(
     return false;
   }
 
+  if (auto *UTP = dyn_cast<UniversalTemplateParmDecl>(Param)) {
+    return CheckUniversalTemplateParameterArgument(UTP, Arg, SugaredConverted,
+                                                   CanonicalConverted, CTAK);
+  }
 
   // Check template template parameters.
   TemplateTemplateParmDecl *TempParm = cast<TemplateTemplateParmDecl>(Param);
@@ -5390,6 +5750,15 @@ bool Sema::CheckTemplateArgument(
   case TemplateArgument::Null:
     llvm_unreachable("Should never see a NULL template argument here");
 
+  case TemplateArgument::Concept:
+    if (CheckPartiallyAppliedConceptTemplateArgument(TempParm, Params, Arg))
+      return true;
+
+    SugaredConverted.push_back(Arg.getArgument());
+    CanonicalConverted.push_back(
+        Context.getCanonicalTemplateArgument(Arg.getArgument()));
+    break;
+
   case TemplateArgument::Template:
   case TemplateArgument::TemplateExpansion:
     if (CheckTemplateTemplateArgument(TempParm, Params, Arg,
@@ -5402,12 +5771,26 @@ bool Sema::CheckTemplateArgument(
     break;
 
   case TemplateArgument::Expression:
-  case TemplateArgument::Type:
+  case TemplateArgument::Type: {
+    auto Kind = 0;
+    switch(TempParm->kind()) {
+      case TemplateNameKind::TNK_Var_template:
+        Kind = 1;
+        break;
+      case TemplateNameKind::TNK_Concept_template:
+        Kind = 2;
+        break;
+      default:
+        break;
+    }
+
     // We have a template template parameter but the template
     // argument does not refer to a template.
     Diag(Arg.getLocation(), diag::err_template_arg_must_be_template)
+      << Kind
       << getLangOpts().CPlusPlus11;
     return true;
+  }
 
   case TemplateArgument::Declaration:
   case TemplateArgument::Integral:
@@ -6114,7 +6497,7 @@ enum NullPointerValueKind {
 /// Determine whether the given template argument is a null pointer
 /// value of the appropriate type.
 static NullPointerValueKind
-isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
+isNullPointerValueTemplateArgument(Sema &S, NamedDecl *Param,
                                    QualType ParamType, Expr *Arg,
                                    Decl *Entity = nullptr) {
   if (Arg->isValueDependent() || Arg->isTypeDependent())
@@ -6219,9 +6602,10 @@ isNullPointerValueTemplateArgument(Sema &S, NonTypeTemplateParmDecl *Param,
 
 /// Checks whether the given template argument is compatible with its
 /// template parameter.
-static bool CheckTemplateArgumentIsCompatibleWithParameter(
-    Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
-    Expr *Arg, QualType ArgType) {
+static bool
+CheckTemplateArgumentIsCompatibleWithParameter(Sema &S, NamedDecl *Param,
+                                               QualType ParamType, Expr *ArgIn,
+                                               Expr *Arg, QualType ArgType) {
   bool ObjCLifetimeConversion;
   if (ParamType->isPointerType() &&
       !ParamType->castAs<PointerType>()->getPointeeType()->isFunctionType() &&
@@ -6277,7 +6661,7 @@ static bool CheckTemplateArgumentIsCompatibleWithParameter(
 /// Checks whether the given template argument is the address
 /// of an object or function according to C++ [temp.arg.nontype]p1.
 static bool CheckTemplateArgumentAddressOfObjectOrFunction(
-    Sema &S, NonTypeTemplateParmDecl *Param, QualType ParamType, Expr *ArgIn,
+    Sema &S, NamedDecl *Param, QualType ParamType, Expr *ArgIn,
     TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {
   bool Invalid = false;
   Expr *Arg = ArgIn;
@@ -6542,11 +6926,9 @@ static bool CheckTemplateArgumentAddressOfObjectOrFunction(
 
 /// Checks whether the given template argument is a pointer to
 /// member constant according to C++ [temp.arg.nontype]p1.
-static bool
-CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param,
-                                     QualType ParamType, Expr *&ResultArg,
-                                     TemplateArgument &SugaredConverted,
-                                     TemplateArgument &CanonicalConverted) {
+static bool CheckTemplateArgumentPointerToMember(
+    Sema &S, NamedDecl *Param, QualType ParamType, Expr *&ResultArg,
+    TemplateArgument &SugaredConverted, TemplateArgument &CanonicalConverted) {
   bool Invalid = false;
 
   Expr *Arg = ResultArg;
@@ -6680,12 +7062,30 @@ CheckTemplateArgumentPointerToMember(Sema &S, NonTypeTemplateParmDecl *Param,
   return true;
 }
 
-ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
-                                       QualType ParamType, Expr *Arg,
+/// Check a template argument against its corresponding
+/// non-type template parameter.
+///
+/// This routine implements the semantics of C++ [temp.arg.nontype].
+/// If an error occurred, it returns ExprError(); otherwise, it
+/// returns the converted template argument. \p ParamType is the
+/// type of the non-type template parameter after it has been instantiated.
+ExprResult Sema::CheckTemplateArgument(NamedDecl *Param, QualType ParamType,
+                                       Expr *Arg,
                                        TemplateArgument &SugaredConverted,
                                        TemplateArgument &CanonicalConverted,
                                        CheckTemplateArgumentKind CTAK) {
   SourceLocation StartLoc = Arg->getBeginLoc();
+  unsigned Depth;
+  QualType OriginalParamType;
+  if (auto *UTP = dyn_cast<UniversalTemplateParmDecl>(Param)) {
+    Depth = UTP->getDepth();
+    OriginalParamType = getASTContext().getAutoType(
+        QualType(), AutoTypeKeyword::DecltypeAuto, false);
+  } else {
+    auto *NTTP = cast<NonTypeTemplateParmDecl>(Param);
+    Depth = NTTP->getDepth();
+    OriginalParamType = NTTP->getType();
+  }
 
   // If the parameter type somehow involves auto, deduce the type now.
   DeducedType *DeducedT = ParamType->getContainedDeducedType();
@@ -6724,8 +7124,7 @@ ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       if (ParamType.isNull())
         return ExprError();
     } else {
-      TemplateDeductionInfo Info(DeductionArg->getExprLoc(),
-                                 Param->getDepth() + 1);
+      TemplateDeductionInfo Info(DeductionArg->getExprLoc(), Depth + 1);
       ParamType = QualType();
       TemplateDeductionResult Result =
           DeduceAutoType(TSI->getTypeLoc(), DeductionArg, ParamType, Info,
@@ -6742,7 +7141,7 @@ ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       } else if (Result != TemplateDeductionResult::Success) {
         Diag(Arg->getExprLoc(),
              diag::err_non_type_template_parm_type_deduction_failure)
-            << Param->getDeclName() << Param->getType() << Arg->getType()
+            << Param->getDeclName() << OriginalParamType << Arg->getType()
             << Arg->getSourceRange();
         NoteTemplateParameterLocation(*Param);
         return ExprError();
@@ -7113,7 +7512,7 @@ ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
       if (IntegerType->isUnsignedIntegerOrEnumerationType() &&
           (OldValue.isSigned() && OldValue.isNegative())) {
         Diag(Arg->getBeginLoc(), diag::warn_template_arg_negative)
-            << toString(OldValue, 10) << toString(Value, 10) << Param->getType()
+            << toString(OldValue, 10) << toString(Value, 10) << OriginalParamType
             << Arg->getSourceRange();
         NoteTemplateParameterLocation(*Param);
       }
@@ -7128,7 +7527,7 @@ ExprResult Sema::CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
         RequiredBits = OldValue.getSignificantBits();
       if (RequiredBits > AllowedBits) {
         Diag(Arg->getBeginLoc(), diag::warn_template_arg_too_large)
-            << toString(OldValue, 10) << toString(Value, 10) << Param->getType()
+            << toString(OldValue, 10) << toString(Value, 10) << OriginalParamType
             << Arg->getSourceRange();
         NoteTemplateParameterLocation(*Param);
       }
@@ -7287,6 +7686,84 @@ static void DiagnoseTemplateParameterListArityMismatch(
     Sema &S, TemplateParameterList *New, TemplateParameterList *Old,
     Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc);
 
+bool Sema::CheckDeclCompatibleWithTemplateTemplate(TemplateDecl *Template,
+                                                   TemplateTemplateParmDecl *Param,
+                                                   const TemplateArgumentLoc &Arg) {
+    // C++0x [temp.arg.template]p1:
+    //   A template-argument for a template template-parameter shall be
+    //   the name of a class template or an alias template, expressed as an
+    //   id-expression. When the template-argument names a class template, only
+    //   primary class templates are considered when matching the
+    //   template template argument with the corresponding parameter;
+    //   partial specializations are not considered even if their
+    //   parameter lists match that of the template template parameter.
+    //
+
+    TemplateNameKind Kind = TNK_Non_template;
+    unsigned DiagFoundKind = 0;
+
+    if(auto * TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(Template)) {
+      switch(TTP->kind()) {
+        case TemplateNameKind::TNK_Concept_template:
+          DiagFoundKind = 3;
+          break;
+        case TemplateNameKind::TNK_Var_template:
+          DiagFoundKind = 2;
+          break;
+        default:
+          DiagFoundKind = 1;
+          break;
+      }
+      Kind = TTP->kind();
+    }
+    else if(isa<ConceptDecl>(Template)) {
+        Kind = TemplateNameKind::TNK_Concept_template;
+        DiagFoundKind = 3;
+    }
+    else if(isa<FunctionTemplateDecl>(Template)) {
+        Kind = TemplateNameKind::TNK_Function_template;
+        DiagFoundKind = 0;
+    }
+    else if(isa<VarTemplateDecl>(Template)) {
+        Kind = TemplateNameKind::TNK_Var_template;
+        DiagFoundKind = 2;
+    }
+    else if(isa<ClassTemplateDecl>(Template)
+             || isa<TypeAliasTemplateDecl>(Template) || isa<BuiltinTemplateDecl>(Template)) {
+         Kind = TemplateNameKind::TNK_Type_template;
+         DiagFoundKind = 1;
+    }
+    else {
+        assert(false && "Unexpected Decl");
+    }
+
+    if(Kind == Param->kind()) {
+        return true;
+    }
+
+    unsigned DiagKind = 0;
+    switch(Param->kind()) {
+    case TemplateNameKind::TNK_Concept_template:
+        DiagKind = 2;
+        break;
+    case TemplateNameKind::TNK_Var_template:
+        DiagKind = 1;
+        break;
+    default:
+        DiagKind = 0;
+        break;
+    }
+    Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template) << DiagKind;
+    Diag(Template->getLocation(), diag::note_template_arg_refers_to_template_here) << DiagFoundKind
+      << Template;
+    return false;
+}
+
+/// Check a template argument against its corresponding
+/// template template parameter.
+///
+/// This routine implements the semantics of C++ [temp.arg.template].
+/// It returns true if an error occurred, and false otherwise.
 bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
                                          TemplateParameterList *Params,
                                          TemplateArgumentLoc &Arg,
@@ -7302,27 +7779,8 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
   if (Template->isInvalidDecl())
     return true;
 
-  // C++0x [temp.arg.template]p1:
-  //   A template-argument for a template template-parameter shall be
-  //   the name of a class template or an alias template, expressed as an
-  //   id-expression. When the template-argument names a class template, only
-  //   primary class templates are considered when matching the
-  //   template template argument with the corresponding parameter;
-  //   partial specializations are not considered even if their
-  //   parameter lists match that of the template template parameter.
-  //
-  // Note that we also allow template template parameters here, which
-  // will happen when we are dealing with, e.g., class template
-  // partial specializations.
-  if (!isa<ClassTemplateDecl>(Template) &&
-      !isa<TemplateTemplateParmDecl>(Template) &&
-      !isa<TypeAliasTemplateDecl>(Template) &&
-      !isa<BuiltinTemplateDecl>(Template)) {
-    assert(isa<FunctionTemplateDecl>(Template) &&
-           "Only function templates are possible here");
-    Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
-    Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
-      << Template;
+  if(!CheckDeclCompatibleWithTemplateTemplate(Template, Param, Arg)) {
+      return true;
   }
 
   // C++1z [temp.arg.template]p3: (DR 150)
@@ -7416,9 +7874,54 @@ void Sema::NoteTemplateParameterLocation(const NamedDecl &Decl) {
                diag::note_template_param_external);
 }
 
-ExprResult Sema::BuildExpressionFromDeclTemplateArgument(
-    const TemplateArgument &Arg, QualType ParamType, SourceLocation Loc,
-    NamedDecl *TemplateParam) {
+bool Sema::CheckPartiallyAppliedConceptTemplateArgument(
+    TemplateTemplateParmDecl *Param, TemplateParameterList *Params,
+    TemplateArgumentLoc &Arg) {
+  PartiallyAppliedConcept *C = Arg.getArgument().getAsPartiallyAppliedConcept();
+  TemplateDecl *Template = C->getNamedConcept();
+  if (Template->isInvalidDecl())
+    return true;
+
+  if (!CheckDeclCompatibleWithTemplateTemplate(Template, Param, Arg)) {
+    return true;
+  }
+  if (Params->size() != 1) {
+    Diag(C->getSourceRange().getBegin(),
+         diag::err_partial_concept_param_must_have_one_arg);
+    Diag(Param->getLocation(),
+         diag::note_concept_template_parameter_declared_here)
+        << Param;
+    return true;
+  }
+  unsigned MinArguments =
+      Template->getTemplateParameters()->getMinRequiredArguments();
+
+  auto Passed = C->getTemplateArgsAsWritten()->getNumTemplateArgs();
+  bool TooFew  = MinArguments > Passed + 1;
+  bool TooMany = Passed +1 > Template->getTemplateParameters()->size() &&
+                 !Template->getTemplateParameters()->hasParameterPack();
+
+  if (TooFew || TooMany) {
+    Diag(C->getSourceRange().getBegin(),
+         diag::err_template_arg_list_different_arity)
+        << (TooFew ? 0 : 1) << /*Concept*/ 5 << Template;
+    Diag(Template->getLocation(), diag::note_template_decl_here)
+        << Template->getTemplateParameters()->getSourceRange();
+    return true;
+  }
+
+  return false;
+}
+
+/// Given a non-type template argument that refers to a
+/// declaration and the type of its corresponding non-type template
+/// parameter, produce an expression that properly refers to that
+/// declaration.
+ExprResult
+Sema::BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
+                                              QualType ParamType,
+                                              SourceLocation Loc,
+                                              NamedDecl *TemplateParam) {
   // C++ [temp.param]p8:
   //
   //   A non-type template-parameter of type "array of T" or
@@ -7698,7 +8201,10 @@ static bool MatchTemplateParameterKind(
     const NamedDecl *OldInstFrom, bool Complain,
     Sema::TemplateParameterListEqualKind Kind, SourceLocation TemplateArgLoc) {
   // Check the actual kind (type, non-type, template).
-  if (Old->getKind() != New->getKind()) {
+  bool OldIsUniversal = Kind == Sema::TPL_TemplateTemplateArgumentMatch &&
+                        Old->getKind() == clang::Decl::UniversalTemplateParm;
+
+  if (!OldIsUniversal && Old->getKind() != New->getKind()) {
     if (Complain) {
       unsigned NextDiag = diag::err_template_param_different_kind;
       if (TemplateArgLoc.isValid()) {
@@ -7741,41 +8247,42 @@ static bool MatchTemplateParameterKind(
     return false;
   }
 
-  // For non-type template parameters, check the type of the parameter.
-  if (NonTypeTemplateParmDecl *OldNTTP
-                                    = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
-    NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
-
-    // If we are matching a template template argument to a template
-    // template parameter and one of the non-type template parameter types
-    // is dependent, then we must wait until template instantiation time
-    // to actually compare the arguments.
-    if (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
-        (!OldNTTP->getType()->isDependentType() &&
-         !NewNTTP->getType()->isDependentType())) {
-      // C++20 [temp.over.link]p6:
-      //   Two [non-type] template-parameters are equivalent [if] they have
-      //   equivalent types ignoring the use of type-constraints for
-      //   placeholder types
-      QualType OldType = S.Context.getUnconstrainedType(OldNTTP->getType());
-      QualType NewType = S.Context.getUnconstrainedType(NewNTTP->getType());
-      if (!S.Context.hasSameType(OldType, NewType)) {
-        if (Complain) {
-          unsigned NextDiag = diag::err_template_nontype_parm_different_type;
-          if (TemplateArgLoc.isValid()) {
-            S.Diag(TemplateArgLoc,
-                   diag::err_template_arg_template_params_mismatch);
-            NextDiag = diag::note_template_nontype_parm_different_type;
+  if (!OldIsUniversal) {
+    // For non-type template parameters, check the type of the parameter.
+    if (NonTypeTemplateParmDecl *OldNTTP =
+            dyn_cast<NonTypeTemplateParmDecl>(Old)) {
+      NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
+
+      // If we are matching a template template argument to a template
+      // template parameter and one of the non-type template parameter types
+      // is dependent, then we must wait until template instantiation time
+      // to actually compare the arguments.
+      if (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
+          (!OldNTTP->getType()->isDependentType() &&
+           !NewNTTP->getType()->isDependentType())) {
+        // C++20 [temp.over.link]p6:
+        //   Two [non-type] template-parameters are equivalent [if] they have
+        //   equivalent types ignoring the use of type-constraints for
+        //   placeholder types
+        QualType OldType = S.Context.getUnconstrainedType(OldNTTP->getType());
+        QualType NewType = S.Context.getUnconstrainedType(NewNTTP->getType());
+        if (!S.Context.hasSameType(OldType, NewType)) {
+          if (Complain) {
+            unsigned NextDiag = diag::err_template_nontype_parm_different_type;
+            if (TemplateArgLoc.isValid()) {
+              S.Diag(TemplateArgLoc,
+                     diag::err_template_arg_template_params_mismatch);
+              NextDiag = diag::note_template_nontype_parm_different_type;
+            }
+            S.Diag(NewNTTP->getLocation(), NextDiag)
+                << NewNTTP->getType() << (Kind != Sema::TPL_TemplateMatch);
+            S.Diag(OldNTTP->getLocation(),
+                   diag::note_template_nontype_parm_prev_declaration)
+                << OldNTTP->getType();
           }
-          S.Diag(NewNTTP->getLocation(), NextDiag)
-            << NewNTTP->getType()
-            << (Kind != Sema::TPL_TemplateMatch);
-          S.Diag(OldNTTP->getLocation(),
-                 diag::note_template_nontype_parm_prev_declaration)
-            << OldNTTP->getType();
-        }
 
-        return false;
+          return false;
+        }
       }
     }
   }
@@ -7785,6 +8292,8 @@ static bool MatchTemplateParameterKind(
   else if (TemplateTemplateParmDecl *OldTTP =
                dyn_cast<TemplateTemplateParmDecl>(Old)) {
     TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
+    if(OldTTP->kind() != NewTTP->kind())
+      return false;
     if (!S.TemplateParameterListsAreEqual(
             NewInstFrom, NewTTP->getTemplateParameters(), OldInstFrom,
             OldTTP->getTemplateParameters(), Complain,
@@ -7797,7 +8306,7 @@ static bool MatchTemplateParameterKind(
 
   if (Kind != Sema::TPL_TemplateParamsEquivalent &&
       Kind != Sema::TPL_TemplateTemplateArgumentMatch &&
-      !isa<TemplateTemplateParmDecl>(Old)) {
+      !isa<TemplateTemplateParmDecl, UniversalTemplateParmDecl>(Old)) {
     const Expr *NewC = nullptr, *OldC = nullptr;
 
     if (isa<TemplateTypeParmDecl>(New)) {
@@ -8182,6 +8691,11 @@ static bool CheckNonTypeTemplatePartialSpecializationArgs(
       if (isa<NonTypeTemplateParmDecl>(DRE->getDecl()))
         continue;
 
+    if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(ArgExpr);
+        ULE && (ULE->isConceptReference() || ULE->isVarDeclReference())) {
+      continue;
+    }
+
     // C++ [temp.class.spec]p9:
     //   Within the argument list of a class template partial
     //   specialization, the following restrictions apply:
@@ -8792,11 +9306,12 @@ void Sema::CheckConceptRedefinition(ConceptDecl *NewDecl,
   Context.setPrimaryMergedDecl(NewDecl, OldConcept->getCanonicalDecl());
 }
 
-bool Sema::CheckConceptUseInDefinition(ConceptDecl *Concept,
+bool Sema::CheckConceptUseInDefinition(NamedDecl *Concept,
                                        SourceLocation Loc) {
-  if (!Concept->isInvalidDecl() && !Concept->hasDefinition()) {
-    Diag(Loc, diag::err_recursive_concept) << Concept;
-    Diag(Concept->getLocation(), diag::note_declared_at);
+  if (auto* CE = llvm::dyn_cast<ConceptDecl>(Concept); CE &&
+          !CE->isInvalidDecl() && !CE->hasDefinition()) {
+    Diag(Loc, diag::err_recursive_concept) << CE;
+    Diag(CE->getLocation(), diag::note_declared_at);
     return true;
   }
   return false;
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index cc095ae67ac40..80bdf5404d492 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -28,6 +28,7 @@
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/Basic/AddressSpaces.h"
@@ -37,9 +38,11 @@
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TemplateKinds.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/Sema.h"
+#include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/APInt.h"
@@ -164,11 +167,7 @@ static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
                                        bool OnlyDeduced, unsigned Level,
                                        llvm::SmallBitVector &Deduced);
 
-/// If the given expression is of a form that permits the deduction
-/// of a non-type template parameter, return the declaration of that
-/// non-type template parameter.
-static const NonTypeTemplateParmDecl *
-getDeducedParameterFromExpr(const Expr *E, unsigned Depth) {
+static const Expr *unwrapExpressionForDeduction(const Expr *E) {
   // If we are within an alias template, the expression may have undergone
   // any number of parameter substitutions already.
   while (true) {
@@ -188,18 +187,107 @@ getDeducedParameterFromExpr(const Expr *E, unsigned Depth) {
     } else
       break;
   }
+  return E;
+}
+
+class NonTypeOrVarTemplateParmDecl {
+public:
+  NonTypeOrVarTemplateParmDecl(const NamedDecl *Template) : Template(Template) {
+    assert(!Template || isa<NonTypeTemplateParmDecl>(Template) ||
+           (isa<TemplateTemplateParmDecl>(Template) &&
+            (cast<TemplateTemplateParmDecl>(Template)->kind() ==
+                 TNK_Var_template ||
+             cast<TemplateTemplateParmDecl>(Template)->kind() ==
+                 TNK_Concept_template)));
+  }
+
+  /*NonTypeOrVarTemplateParmDecl(const NonTypeTemplateParmDecl* NTTP)
+      : Template(NTTP) {}
+  NonTypeOrVarTemplateParmDecl(const TemplateTemplateParmDecl* TTP)
+      : Template(TTP) {
+    assert(TTP->kind() == TNK_Var_template || TTP->kind() ==
+  clang::TNK_Concept_template);
+  }*/
+
+  QualType getType() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return NTTP->getType();
+    return getTemplate()->kind() == TNK_Concept_template
+               ? getTemplate()->getASTContext().BoolTy
+               : getTemplate()->getASTContext().DependentTy;
+  }
 
+  unsigned getDepth() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return NTTP->getDepth();
+    return getTemplate()->getDepth();
+  }
+
+  unsigned getIndex() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return NTTP->getIndex();
+    return getTemplate()->getIndex();
+  }
+
+  const TemplateTemplateParmDecl *getTemplate() const {
+    return cast<TemplateTemplateParmDecl>(Template);
+  }
+
+  const NonTypeTemplateParmDecl *getNTTP() const {
+    return cast<NonTypeTemplateParmDecl>(Template);
+  }
+
+  TemplateParameter asTemplateParam() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return const_cast<NonTypeTemplateParmDecl *>(NTTP);
+    return const_cast<TemplateTemplateParmDecl *>(getTemplate());
+  }
+
+  bool isExpandedParameterPack() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return NTTP->isExpandedParameterPack();
+    return getTemplate()->isExpandedParameterPack();
+  }
+
+  SourceLocation getLocation() const {
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Template))
+      return NTTP->getLocation();
+    return getTemplate()->getLocation();
+  }
+
+  operator bool() const { return Template; }
+
+private:
+  const NamedDecl *Template;
+};
+
+/// If the given expression is of a form that permits the deduction
+/// of a non-type template parameter, return the declaration of that
+/// non-type template parameter.
+static NonTypeOrVarTemplateParmDecl
+getDeducedNTTParameterFromExpr(const Expr *E, unsigned Depth) {
+  // If we are within an alias template, the expression may have undergone
+  // any number of parameter substitutions already.
+  E = unwrapExpressionForDeduction(E);
   if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
     if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
       if (NTTP->getDepth() == Depth)
         return NTTP;
 
+  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E);
+      ULE && (ULE->isConceptReference() || ULE->isVarDeclReference())) {
+    if (auto *TTP = ULE->getTemplateTemplateDecl()) {
+
+      if (TTP->getDepth() == Depth)
+        return TTP;
+    }
+  }
   return nullptr;
 }
 
-static const NonTypeTemplateParmDecl *
-getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) {
-  return getDeducedParameterFromExpr(E, Info.getDeducedDepth());
+static const NonTypeOrVarTemplateParmDecl
+getDeducedNTTParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) {
+  return getDeducedNTTParameterFromExpr(E, Info.getDeducedDepth());
 }
 
 /// Determine whether two declaration pointers refer to the same
@@ -403,29 +491,28 @@ checkDeducedTemplateArguments(ASTContext &Context,
 /// deduction is funneled through here.
 static TemplateDeductionResult
 DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
-                              const NonTypeTemplateParmDecl *NTTP,
+                              const NonTypeOrVarTemplateParmDecl NTTP,
                               const DeducedTemplateArgument &NewDeduced,
                               QualType ValueType, TemplateDeductionInfo &Info,
                               bool PartialOrdering,
                               SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                               bool *HasDeducedAnyParam) {
-  assert(NTTP->getDepth() == Info.getDeducedDepth() &&
+  assert(NTTP.getDepth() == Info.getDeducedDepth() &&
          "deducing non-type template argument with wrong depth");
 
   DeducedTemplateArgument Result = checkDeducedTemplateArguments(
-      S.Context, Deduced[NTTP->getIndex()], NewDeduced);
+      S.Context, Deduced[NTTP.getIndex()], NewDeduced);
   if (Result.isNull()) {
-    Info.Param = const_cast<NonTypeTemplateParmDecl*>(NTTP);
-    Info.FirstArg = Deduced[NTTP->getIndex()];
+    Info.Param = NTTP.asTemplateParam();
+    Info.FirstArg = Deduced[NTTP.getIndex()];
     Info.SecondArg = NewDeduced;
     return TemplateDeductionResult::Inconsistent;
   }
-
-  Deduced[NTTP->getIndex()] = Result;
+  Deduced[NTTP.getIndex()] = Result;
   if (!S.getLangOpts().CPlusPlus17)
     return TemplateDeductionResult::Success;
 
-  if (NTTP->isExpandedParameterPack())
+  if (NTTP.isExpandedParameterPack())
     // FIXME: We may still need to deduce parts of the type here! But we
     // don't have any way to find which slice of the type to use, and the
     // type stored on the NTTP itself is nonsense. Perhaps the type of an
@@ -434,7 +521,7 @@ DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
 
   // Get the type of the parameter for deduction. If it's a (dependent) array
   // or function type, we will not have decayed it yet, so do that now.
-  QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType());
+  QualType ParamType = S.Context.getAdjustedParameterType(NTTP.getType());
   if (auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
     ParamType = Expansion->getPattern();
 
@@ -461,7 +548,7 @@ DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
 /// from the given integral constant.
 static TemplateDeductionResult DeduceNonTypeTemplateArgument(
     Sema &S, TemplateParameterList *TemplateParams,
-    const NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
+    NonTypeOrVarTemplateParmDecl NTTP, const llvm::APSInt &Value,
     QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
     bool PartialOrdering, SmallVectorImpl<DeducedTemplateArgument> &Deduced,
     bool *HasDeducedAnyParam) {
@@ -476,14 +563,14 @@ static TemplateDeductionResult DeduceNonTypeTemplateArgument(
 /// from the given null pointer template argument type.
 static TemplateDeductionResult
 DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
-                              const NonTypeTemplateParmDecl *NTTP,
+                              NonTypeOrVarTemplateParmDecl NTTP,
                               QualType NullPtrType, TemplateDeductionInfo &Info,
                               bool PartialOrdering,
                               SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                               bool *HasDeducedAnyParam) {
   Expr *Value = S.ImpCastExprToType(
                      new (S.Context) CXXNullPtrLiteralExpr(S.Context.NullPtrTy,
-                                                           NTTP->getLocation()),
+                                                           NTTP.getLocation()),
                      NullPtrType,
                      NullPtrType->isMemberPointerType() ? CK_NullToMemberPointer
                                                         : CK_NullToPointer)
@@ -499,7 +586,7 @@ DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
 /// \returns true if deduction succeeded, false otherwise.
 static TemplateDeductionResult
 DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
-                              const NonTypeTemplateParmDecl *NTTP, Expr *Value,
+                              NonTypeOrVarTemplateParmDecl NTTP, Expr *Value,
                               TemplateDeductionInfo &Info, bool PartialOrdering,
                               SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                               bool *HasDeducedAnyParam) {
@@ -514,7 +601,7 @@ DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
 /// \returns true if deduction succeeded, false otherwise.
 static TemplateDeductionResult
 DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
-                              const NonTypeTemplateParmDecl *NTTP, ValueDecl *D,
+                              NonTypeOrVarTemplateParmDecl NTTP, ValueDecl *D,
                               QualType T, TemplateDeductionInfo &Info,
                               bool PartialOrdering,
                               SmallVectorImpl<DeducedTemplateArgument> &Deduced,
@@ -591,6 +678,23 @@ static TemplateDeductionResult DeduceTemplateArguments(
   return TemplateDeductionResult::NonDeducedMismatch;
 }
 
+static TemplateDeductionResult
+DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
+                        UniversalTemplateParameterName *Param,
+                        TemplateArgument Arg, TemplateDeductionInfo &Info,
+                        SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+
+  UniversalTemplateParmDecl *Decl = Param->getDecl();
+  assert(Decl && "unexpected null parameter");
+
+  if (Decl->getDepth() != Info.getDeducedDepth())
+    return TemplateDeductionResult::Success;;
+
+  DeducedTemplateArgument NewDeduced(Arg);
+  Deduced[Decl->getIndex()] = Arg;
+  return TemplateDeductionResult::Success;;
+}
+
 /// Deduce the template arguments by comparing the template parameter
 /// type (which is a template-id) with the template argument type.
 ///
@@ -722,6 +826,18 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
                                  HasDeducedAnyParam);
 }
 
+/*static TemplateDeductionResult DeduceNonTypeTemplateSpecArguments(
+    Sema &S, TemplateParameterList *TemplateParams, Expr *P, TemplateArgument A,
+    TemplateDeductionInfo &Info,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+  switch (A.getKind()) {
+  case TemplateArgument::Integral: {
+    QualType T = A.getIntegralType();
+    break;
+  }
+  }
+}*/
+
 static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T) {
   assert(T->isCanonicalUnqualified());
 
@@ -760,9 +876,13 @@ static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
 static TemplateParameter makeTemplateParameter(Decl *D) {
   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
     return TemplateParameter(TTP);
+
   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
     return TemplateParameter(NTTP);
 
+  if (UniversalTemplateParmDecl *UTP = dyn_cast<UniversalTemplateParmDecl>(D))
+    return TemplateParameter(UTP);
+
   return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
 }
 
@@ -1926,14 +2046,14 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
         return Result;
 
       // Determine the array bound is something we can deduce.
-      const NonTypeTemplateParmDecl *NTTP =
-          getDeducedParameterFromExpr(Info, DAP->getSizeExpr());
+      NonTypeOrVarTemplateParmDecl NTTP =
+          getDeducedNTTParameterFromExpr(Info, DAP->getSizeExpr());
       if (!NTTP)
         return TemplateDeductionResult::Success;
 
       // We can perform template argument deduction for the given non-type
       // template parameter.
-      assert(NTTP->getDepth() == Info.getDeducedDepth() &&
+      assert(NTTP.getDepth() == Info.getDeducedDepth() &&
              "saw non-type template parameter with wrong depth");
       if (const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
         llvm::APSInt Size(CAA->getSize());
@@ -1990,10 +2110,10 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
       // deducing through the noexcept-specifier if it's part of the canonical
       // type. libstdc++ relies on this.
       Expr *NoexceptExpr = FPP->getNoexceptExpr();
-      if (const NonTypeTemplateParmDecl *NTTP =
-              NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr)
+      if (NonTypeOrVarTemplateParmDecl NTTP =
+              NoexceptExpr ? getDeducedNTTParameterFromExpr(Info, NoexceptExpr)
                            : nullptr) {
-        assert(NTTP->getDepth() == Info.getDeducedDepth() &&
+        assert(NTTP.getDepth() == Info.getDeducedDepth() &&
                "saw non-type template parameter with wrong depth");
 
         llvm::APSInt Noexcept(1);
@@ -2167,8 +2287,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the vector size, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2193,8 +2313,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the vector size, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2222,8 +2342,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the vector size, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2247,8 +2367,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the vector size, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2324,8 +2444,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
               return TemplateDeductionResult::NonDeducedMismatch;
             }
 
-            const NonTypeTemplateParmDecl *NTTP =
-                getDeducedParameterFromExpr(Info, ParamExpr);
+            NonTypeOrVarTemplateParmDecl NTTP =
+                getDeducedNTTParameterFromExpr(Info, ParamExpr);
             if (!NTTP)
               return TemplateDeductionResult::Success;
 
@@ -2371,8 +2491,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the address space, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, ASP->getAddrSpaceExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2396,8 +2516,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
           return Result;
 
         // Perform deduction on the address space, if we can.
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, ASP->getAddrSpaceExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2416,8 +2536,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
         if (IP->isUnsigned() != IA->isUnsigned())
           return TemplateDeductionResult::NonDeducedMismatch;
 
-        const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, IP->getNumBitsExpr());
+        NonTypeOrVarTemplateParmDecl NTTP =
+            getDeducedNTTParameterFromExpr(Info, IP->getNumBitsExpr());
         if (!NTTP)
           return TemplateDeductionResult::Success;
 
@@ -2506,6 +2626,12 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
     Info.SecondArg = A;
     return TemplateDeductionResult::NonDeducedMismatch;
 
+  case TemplateArgument::Universal:
+    return DeduceTemplateArguments(S, TemplateParams,
+                                   P.getAsUniversalTemplateParameterName(), A,
+                                   Info, Deduced);
+
+  case TemplateArgument::UniversalExpansion:
   case TemplateArgument::TemplateExpansion:
     llvm_unreachable("caller should handle pack expansions");
 
@@ -2546,13 +2672,13 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
     return TemplateDeductionResult::NonDeducedMismatch;
 
   case TemplateArgument::Expression:
-    if (const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, P.getAsExpr())) {
+      if (NonTypeOrVarTemplateParmDecl NTTP =
+              getDeducedNTTParameterFromExpr(Info, P.getAsExpr())) {
       switch (A.getKind()) {
       case TemplateArgument::Integral:
       case TemplateArgument::Expression:
       case TemplateArgument::StructuralValue:
-        return DeduceNonTypeTemplateArgument(
+          return DeduceNonTypeTemplateArgument(
             S, TemplateParams, NTTP, DeducedTemplateArgument(A),
             A.getNonTypeTemplateArgumentType(), Info, PartialOrdering, Deduced,
             HasDeducedAnyParam);
@@ -2578,7 +2704,6 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
       }
       llvm_unreachable("Unknown template argument kind");
     }
-
     // Can't deduce anything, but that's okay.
     return TemplateDeductionResult::Success;
   case TemplateArgument::Pack:
@@ -2871,6 +2996,13 @@ Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
           Context, Arg, Builder.getWithLocInContext(Context), Loc, Loc);
     }
 
+    case TemplateArgument::Universal:
+    case TemplateArgument::UniversalExpansion: {
+      UniversalTemplateParameterName *N =
+          Arg.getAsUniversalTemplateParameterOrPattern();
+      return TemplateArgumentLoc(Context, Arg, N);
+    }
+
   case TemplateArgument::Expression:
     return TemplateArgumentLoc(Arg, Arg.getAsExpr());
 
@@ -4393,8 +4525,8 @@ static TemplateDeductionResult DeduceFromInitializerList(
   //   from the length of the initializer list.
   if (auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
     // Determine the array bound is something we can deduce.
-    if (const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) {
+    if (NonTypeOrVarTemplateParmDecl NTTP = getDeducedNTTParameterFromExpr(
+            Info, DependentArrTy->getSizeExpr())) {
       // We can perform template argument deduction for the given non-type
       // template parameter.
       // C++ [temp.deduct.type]p13:
@@ -5083,7 +5215,7 @@ static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
                                                AutoTypeLoc TypeLoc,
                                                QualType Deduced) {
   ConstraintSatisfaction Satisfaction;
-  ConceptDecl *Concept = Type.getTypeConstraintConcept();
+  ConceptDecl *Concept = cast<ConceptDecl>(Type.getTypeConstraintConcept());
   TemplateArgumentListInfo TemplateArgs(TypeLoc.getLAngleLoc(),
                                         TypeLoc.getRAngleLoc());
   TemplateArgs.addArgument(
@@ -6512,6 +6644,19 @@ struct MarkUsedTemplateParameterVisitor :
         Used[NTTP->getIndex()] = true;
     return true;
   }
+
+  /*bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *ULE) {
+    if (ULE->isConceptReference() || ULE->isVarDeclReference()) {
+      if (auto *TTP = ULE->getTemplateTemplateDecl()) {
+        if (TTP->getDepth() == Depth)
+          Used[TTP->getIndex()] = true;
+      }
+      for (auto &TLoc : ULE->template_arguments())
+        RecursiveASTVisitor<MarkUsedTemplateParameterVisitor>::
+            TraverseTemplateArgumentLoc(TLoc);
+    }
+    return true;
+  }*/
 };
 }
 
@@ -6533,17 +6678,28 @@ MarkUsedTemplateParameters(ASTContext &Ctx,
   if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
     E = Expansion->getPattern();
 
-  const NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(E, Depth);
-  if (!NTTP)
+  E = unwrapExpressionForDeduction(E);
+  /*if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E);
+      ULE && (ULE->isConceptReference() || ULE->isVarDeclReference())) {
+    if (const auto *TTP = ULE->getTemplateTemplateDecl())
+      Used[TTP->getIndex()] = true;
+    for (auto &TLoc : ULE->template_arguments())
+      MarkUsedTemplateParameters(Ctx, TLoc.getArgument(), OnlyDeduced, Depth,
+                                 Used);
     return;
+  }*/
 
-  if (NTTP->getDepth() == Depth)
-    Used[NTTP->getIndex()] = true;
+  const NonTypeOrVarTemplateParmDecl NTTP =
+      getDeducedNTTParameterFromExpr(E, Depth);
+  if (!NTTP)
+    return;
+  if (NTTP.getDepth() == Depth)
+    Used[NTTP.getIndex()] = true;
 
   // In C++17 mode, additional arguments may be deduced from the type of a
   // non-type argument.
   if (Ctx.getLangOpts().CPlusPlus17)
-    MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used);
+    MarkUsedTemplateParameters(Ctx, NTTP.getType(), OnlyDeduced, Depth, Used);
 }
 
 /// Mark the template parameters that are used by the given
@@ -6588,6 +6744,17 @@ MarkUsedTemplateParameters(ASTContext &Ctx,
                                Depth, Used);
 }
 
+/// Mark the template parameters that are used by the given
+/// template argument
+static void MarkUsedTemplateParameters(ASTContext &Ctx,
+                                       UniversalTemplateParameterName *Name,
+                                       bool OnlyDeduced, unsigned Depth,
+                                       llvm::SmallBitVector &Used) {
+  UniversalTemplateParmDecl *UTP = Name->getDecl();
+  if (UTP->getDepth() == Depth)
+    Used[UTP->getIndex()] = true;
+}
+
 /// Mark the template parameters that are used by the given
 /// type.
 static void
@@ -6921,6 +7088,13 @@ MarkUsedTemplateParameters(ASTContext &Ctx,
                                OnlyDeduced, Depth, Used);
     break;
 
+  case TemplateArgument::Universal:
+  case TemplateArgument::UniversalExpansion:
+    MarkUsedTemplateParameters(
+        Ctx, TemplateArg.getAsUniversalTemplateParameterOrPattern(),
+        OnlyDeduced, Depth, Used);
+    break;
+
   case TemplateArgument::Expression:
     MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
                                Depth, Used);
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 55f38743e2768..5a93c3243089f 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -15,15 +15,18 @@
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/ASTMutationListener.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
+#include "clang/AST/TemplateBase.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeVisitor.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Stack.h"
 #include "clang/Basic/TargetInfo.h"
@@ -37,11 +40,13 @@
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/TemplateInstCallback.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLForwardCompat.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/TimeProfiler.h"
+#include <cassert>
 #include <optional>
 
 using namespace clang;
@@ -1456,6 +1461,9 @@ namespace {
     /// this declaration.
     Decl *TransformDecl(SourceLocation Loc, Decl *D);
 
+    bool InjectAdditionalArgumentsFromPartiallyAppliedConcept(
+        TemplateArgumentListInfo &Args, TemplateDecl *D);
+
     void transformAttrs(Decl *Old, Decl *New) {
       SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
     }
@@ -1536,6 +1544,16 @@ namespace {
                           QualType ObjectType = QualType(),
                           NamedDecl *FirstQualifierInScope = nullptr,
                           bool AllowInjectedClassName = false);
+    TemplateArgument
+    TransformNamedTemplateTemplateArgument(CXXScopeSpec &SS, TemplateName Name,
+                                           SourceLocation NameLoc);
+
+    NamedDecl *
+    TransformUniversalTemplateParameter(UniversalTemplateParmDecl *D,
+                                        unsigned SubstitutedLevels = 0);
+
+    TemplateArgument
+    TransformUniversalTemplateArgument(UniversalTemplateParameterName *Name);
 
     const CXXAssumeAttr *TransformCXXAssumeAttr(const CXXAssumeAttr *AA);
     const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);
@@ -1797,8 +1815,7 @@ namespace {
 
   private:
     ExprResult
-    transformNonTypeTemplateParmRef(Decl *AssociatedDecl,
-                                    const NonTypeTemplateParmDecl *parm,
+    transformNonTypeTemplateParmRef(Decl *AssociatedDecl, const NamedDecl *parm,
                                     SourceLocation loc, TemplateArgument arg,
                                     std::optional<unsigned> PackIndex);
   };
@@ -1849,7 +1866,12 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
         Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
       }
 
+      if (Arg.getKind() == clang::TemplateArgument::Concept) {
+        return Arg.getAsPartiallyAppliedConcept()->getNamedConcept();
+      }
+
       TemplateName Template = Arg.getAsTemplate();
+
       assert(!Template.isNull() && Template.getAsTemplateDecl() &&
              "Wrong kind of template template argument");
       return Template.getAsTemplateDecl();
@@ -1859,9 +1881,31 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
     // template parameter.
   }
 
+  if (UniversalTemplateParmDecl *UTP = dyn_cast<UniversalTemplateParmDecl>(D);
+      UTP && UTP->getDepth() < TemplateArgs.getNumLevels()) {
+    D = TransformUniversalTemplateParameter(UTP);
+  }
+
   return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
 }
 
+bool TemplateInstantiator::InjectAdditionalArgumentsFromPartiallyAppliedConcept(
+    TemplateArgumentListInfo &Args, TemplateDecl *D) {
+  auto [Depth, Index] = getDepthAndIndex(D);
+  if (Depth >= TemplateArgs.getNumLevels())
+    return false;
+  if (!TemplateArgs.hasTemplateArgument(Depth, Index))
+    return false;
+  TemplateArgument Arg = TemplateArgs(Depth, Index);
+  if (Arg.getKind() != clang::TemplateArgument::Concept)
+    return false;
+  PartiallyAppliedConcept *C = Arg.getAsPartiallyAppliedConcept();
+  for (auto &Arg : C->getTemplateArgsAsWritten()->arguments()) {
+    Args.addArgument(Arg);
+  }
+  return true;
+}
+
 Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
   Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
   if (!Inst)
@@ -2054,6 +2098,189 @@ TemplateName TemplateInstantiator::TransformTemplateName(
                                           AllowInjectedClassName);
 }
 
+TemplateArgument TemplateInstantiator::TransformNamedTemplateTemplateArgument(
+    CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc) {
+  if (TemplateTemplateParmDecl *TTP =
+          dyn_cast_or_null<TemplateTemplateParmDecl>(
+              Name.getAsTemplateDecl())) {
+    if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
+      // If the corresponding template argument is NULL or non-existent, it's
+      // because we are performing instantiation from explicitly-specified
+      // template arguments in a function template, but there were some
+      // arguments left unspecified.
+      if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
+                                            TTP->getPosition()))
+        return TemplateArgument(Name);
+
+      TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
+      if (Arg.getKind() == TemplateArgument::Concept) {
+        PartiallyAppliedConcept *C = Arg.getAsPartiallyAppliedConcept();
+        TemplateDecl *T = cast_or_null<TemplateDecl>(getDerived().TransformDecl(
+            C->getConceptNameLoc(), C->getNamedConcept()));
+        if (!T)
+          return TemplateArgument();
+
+        if (T == C->getNamedConcept() && !getDerived().AlwaysRebuild())
+          return Arg;
+
+        DeclarationNameInfo NameInfo = C->getConceptNameInfo();
+        if (NameInfo.getName()) {
+          NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
+          if (!NameInfo.getName())
+            return TemplateArgument();
+        }
+
+        TemplateArgumentListInfo NewTemplateArgs;
+        NewTemplateArgs.setLAngleLoc(
+            C->getTemplateArgsAsWritten()->getLAngleLoc());
+        NewTemplateArgs.setLAngleLoc(
+            C->getTemplateArgsAsWritten()->getRAngleLoc());
+        for (auto &Arg : C->getTemplateArgsAsWritten()->arguments())
+          NewTemplateArgs.addArgument(Arg);
+
+        PartiallyAppliedConcept *Transformed =
+            SemaRef.BuildPartiallyAppliedConcept(C->getNestedNameSpecifierLoc(),
+                                                 C->getConceptKWLoc(), NameInfo,
+                                                 T, NewTemplateArgs);
+        if (!Transformed)
+          return TemplateArgument(Transformed);
+      }
+    }
+  }
+  TemplateName TN = getDerived().TransformTemplateName(SS, Name, NameLoc);
+  if (!TN.isNull())
+    return TN;
+  return TemplateArgument();
+}
+
+static TemplateNameKind getTemplateNameKind(TemplateName Name) {
+  auto *TD = Name.getAsTemplateDecl();
+  assert(TD);
+  if (isa<ClassTemplateDecl, TypeAliasTemplateDecl>(TD))
+    return TemplateNameKind::TNK_Type_template;
+  if (isa<VarTemplateDecl>(TD))
+    return TemplateNameKind::TNK_Var_template;
+  if (isa<ConceptDecl>(TD))
+    return TemplateNameKind::TNK_Concept_template;
+  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
+    return TTP->kind();
+  llvm_unreachable("Unexpected template kind");
+}
+
+NamedDecl *TemplateInstantiator::TransformUniversalTemplateParameter(
+    UniversalTemplateParmDecl *UTP, unsigned SubstitutedLevels) {
+  if (!TemplateArgs.hasTemplateArgument(UTP->getDepth() - SubstitutedLevels,
+                                        UTP->getPosition()))
+    return UTP;
+  TemplateArgument Arg =
+      TemplateArgs(UTP->getDepth() - SubstitutedLevels, UTP->getPosition());
+
+  auto [AssociatedDecl, Final] =
+      TemplateArgs.getAssociatedDecl(UTP->getDepth());
+  // assert(Final && "TODO corentin - incomplete pack expansion");
+  std::optional<unsigned> PackIndex;
+  if (UTP->isParameterPack()) {
+    assert(Arg.getKind() == TemplateArgument::Pack && "Missing argument pack");
+    if (getSema().ArgumentPackSubstitutionIndex == -1) {
+      assert(false && "TODO corentin");
+    }
+    PackIndex = getPackIndex(Arg);
+    Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
+  }
+
+  switch (Arg.getKind()) {
+  case clang::TemplateArgument::Type: {
+    TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
+        SemaRef.Context, UTP->getDeclContext(), UTP->getBeginLoc(),
+        UTP->getLocation(), UTP->getDepth() - SubstitutedLevels,
+        UTP->getIndex(), UTP->getIdentifier(),
+        /*was declared with typename=*/false, UTP->isParameterPack(),
+        /*Has Type Constraints=*/false, 0);
+    return cast<NamedDecl>(
+        getDerived().TransformDecl(Inst->getLocation(), Inst));
+  }
+  case TemplateArgument::Declaration:
+  case TemplateArgument::Expression:
+  case TemplateArgument::NullPtr:
+  case TemplateArgument::Integral: {
+    QualType Type = SemaRef.Context.getAutoType(
+        QualType(), AutoTypeKeyword::DecltypeAuto, false);
+    TypeSourceInfo *TInfo =
+        SemaRef.Context.getTrivialTypeSourceInfo(Type, UTP->getBeginLoc());
+    NonTypeTemplateParmDecl *Inst = NonTypeTemplateParmDecl::Create(
+        SemaRef.Context, UTP->getDeclContext(), UTP->getBeginLoc(),
+        UTP->getLocation(), UTP->getDepth() - SubstitutedLevels,
+        UTP->getIndex(), UTP->getIdentifier(), Type, UTP->isParameterPack(),
+        TInfo);
+    return cast<NamedDecl>(
+        getDerived().TransformDecl(Inst->getLocation(), Inst));
+  }
+  case TemplateArgument::Template: {
+    TemplateName N = Arg.getAsTemplate();
+    assert(!N.isNull() && "unexpected null template");
+    TemplateDecl *D = N.getAsTemplateDecl();
+    assert(D && "unexpected null template declaration");
+    TemplateTemplateParmDecl *Inst = TemplateTemplateParmDecl::Create(
+        SemaRef.Context, UTP->getDeclContext(), UTP->getBeginLoc(),
+        UTP->getDepth() - SubstitutedLevels, UTP->getIndex(),
+        UTP->isParameterPack(), UTP->getIdentifier(), getTemplateNameKind(N),
+        /*isTypename*/false,
+        D->getTemplateParameters());
+    return cast<NamedDecl>(
+        getDerived().TransformDecl(Inst->getLocation(), Inst));
+
+    break;
+  }
+  case TemplateArgument::TemplateExpansion:
+  case TemplateArgument::UniversalExpansion:
+  case TemplateArgument::Pack:
+  case TemplateArgument::Concept:
+    assert(false && "non implemented");
+    break;
+
+  case TemplateArgument::Universal:
+    return UTP;
+
+  case TemplateArgument::Null:
+    llvm_unreachable("Unexepected null template");
+  }
+  return nullptr;
+}
+
+TemplateArgument TemplateInstantiator::TransformUniversalTemplateArgument(
+    UniversalTemplateParameterName *Name) {
+  UniversalTemplateParmDecl *Old = Name->getDecl();
+  Decl *D = getDerived().TransformDecl(Name->getDecl()->getLocation(),
+                                       Name->getDecl());
+  if (isa<UniversalTemplateParmDecl>(D)) {
+    return inherited::TransformUniversalTemplateArgument(Name);
+  }
+  // If the template parameter is a type, build a type template argument
+  // matching that type
+  if (auto *TypeParam = dyn_cast<TemplateTypeParmDecl>(D)) {
+    QualType Result = getSema().Context.getTemplateTypeParmType(
+        Old->getDepth(), Old->getIndex(), Old->isParameterPack(), TypeParam);
+    return TemplateArgument(Result);
+  }
+  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
+    TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
+    if (Arg.getKind() == TemplateArgument::Expression) {
+      if (auto *DRE = dyn_cast<DeclRefExpr>(Arg.getAsExpr())) {
+        return DRE;
+      }
+    }
+    DeclRefExpr *E = SemaRef.BuildDeclRefExpr(
+        NTTP, NTTP->getType(), ExprValueKind::VK_LValue, Name->getNameInfo());
+    return TemplateArgument(E);
+  }
+  if (isa<TemplateTemplateParmDecl>(D)) {
+    TemplateName N(cast<TemplateDecl>(D));
+    return TemplateArgument(N);
+    assert(false && "template template args not implemented");
+  }
+  llvm_unreachable("Unknown universal parameter kind");
+}
+
 ExprResult
 TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
   if (!E->isTypeDependent())
@@ -2190,22 +2417,25 @@ TemplateInstantiator::TransformCodeAlignAttr(const CodeAlignAttr *CA) {
 }
 
 ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
-    Decl *AssociatedDecl, const NonTypeTemplateParmDecl *parm,
-    SourceLocation loc, TemplateArgument arg,
-    std::optional<unsigned> PackIndex) {
+    Decl *AssociatedDecl, const NamedDecl *parm, SourceLocation loc,
+    TemplateArgument arg, std::optional<unsigned> PackIndex) {
   ExprResult result;
 
   // Determine the substituted parameter type. We can usually infer this from
   // the template argument, but not always.
   auto SubstParamType = [&] {
-    QualType T;
-    if (parm->isExpandedParameterPack())
-      T = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
-    else
-      T = parm->getType();
-    if (parm->isParameterPack() && isa<PackExpansionType>(T))
-      T = cast<PackExpansionType>(T)->getPattern();
-    return SemaRef.SubstType(T, TemplateArgs, loc, parm->getDeclName());
+    if (auto NTTP = dyn_cast<NonTypeTemplateParmDecl>(parm)) {
+      QualType T;
+      if (NTTP->isExpandedParameterPack())
+        T = NTTP->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
+      else
+        T = NTTP->getType();
+      if (parm->isParameterPack() && isa<PackExpansionType>(T))
+        T = cast<PackExpansionType>(T)->getPattern();
+      return SemaRef.SubstType(T, TemplateArgs, loc, parm->getDeclName());
+    }
+    return SemaRef.SubstType(arg.getAsExpr()->getType(), TemplateArgs, loc,
+                             parm->getDeclName());
   };
 
   bool refParam = false;
@@ -2261,7 +2491,9 @@ ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
   // FIXME: Don't put subst node on final replacement.
   return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
       resultExpr->getType(), resultExpr->getValueKind(), loc, resultExpr,
-      AssociatedDecl, parm->getIndex(), PackIndex, refParam);
+      AssociatedDecl,
+      clang::getDepthAndIndex(const_cast<NamedDecl *>(parm)).second, PackIndex,
+      refParam);
 }
 
 ExprResult
@@ -4275,6 +4507,124 @@ bool Sema::SubstTemplateArguments(
   return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
 }
 
+ExprResult
+Sema::SubstConceptTemplateArguments(const ConceptSpecializationExpr *CSE,
+                                    const Expr *ConstraintExpr,
+                                    const MultiLevelTemplateArgumentList &MLTAL,
+                                    ArrayRef<TemplateArgument> Args) {
+  TemplateInstantiator Instantiator(*this, MLTAL, SourceLocation(),
+                                    DeclarationName());
+  auto *ArgsAsWritten = CSE->getTemplateArgsAsWritten();
+  TemplateArgumentListInfo SubstArgs(ArgsAsWritten->getLAngleLoc(),
+                                     ArgsAsWritten->getRAngleLoc());
+
+  Sema::InstantiatingTemplate Inst(
+      *this, ArgsAsWritten->arguments().front().getSourceRange().getBegin(),
+      Sema::InstantiatingTemplate::ParameterMappingSubstitution{},
+      CSE->getNamedConcept(),
+      ArgsAsWritten->arguments().front().getSourceRange());
+
+  if (Instantiator.TransformConceptTemplateArguments(
+          ArgsAsWritten->getTemplateArgs(),
+          ArgsAsWritten->getTemplateArgs() +
+              ArgsAsWritten->getNumTemplateArgs(),
+          SubstArgs))
+    return true;
+
+  llvm::SmallVector<TemplateArgument, 4> NewArgList;
+  NewArgList.reserve(SubstArgs.arguments().size());
+  for (const auto &ArgLoc : SubstArgs.arguments())
+    NewArgList.push_back(ArgLoc.getArgument());
+
+  Sema::SFINAETrap Trap(*this);
+  MultiLevelTemplateArgumentList MLTALForConstraint =
+      getTemplateInstantiationArgs(CSE->getNamedConcept(), CSE->getNamedConcept()->getDeclContext(), /*Final=*/false,
+                                   NewArgList,
+                                   /*RelativeToPrimary=*/true,
+                                   /*Pattern=*/nullptr,
+                                   /*ForConstraintInstantiation=*/true);
+
+  struct ConstraintExprTransformer : TreeTransform<ConstraintExprTransformer> {
+    using Base = TreeTransform<ConstraintExprTransformer>;
+    MultiLevelTemplateArgumentList &MLTAL;
+
+    ConstraintExprTransformer(Sema &SemaRef,
+                              MultiLevelTemplateArgumentList &MLTAL)
+        : TreeTransform(SemaRef), MLTAL(MLTAL) {}
+
+    ExprResult TransformExpr(Expr *E) {
+      if (!E)
+        return E;
+      switch (E->getStmtClass()) {
+      case Stmt::BinaryOperatorClass:
+      case Stmt::ConceptSpecializationExprClass:
+      case Stmt::ParenExprClass:
+      case Stmt::UnresolvedLookupExprClass:
+        return Base::TransformExpr(E);
+      default:
+        break;
+      }
+      return E;
+    }
+
+    ExprResult
+    TransformConceptSpecializationExpr(ConceptSpecializationExpr *E) {
+      return SemaRef.SubstConstraintExpr(E, MLTAL);
+    }
+
+    ExprResult TransformBinaryOperator(BinaryOperator *E) {
+      if (!(E->getOpcode() == BinaryOperatorKind::BO_LAnd ||
+            E->getOpcode() == BinaryOperatorKind::BO_LOr))
+        return E;
+
+      ExprResult LHS = TransformExpr(E->getLHS());
+      if (LHS.isInvalid())
+        return ExprError();
+
+      ExprResult RHS = TransformExpr(E->getRHS());
+      if (RHS.isInvalid())
+        return ExprError();
+
+      if (LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
+        return E;
+
+      return BinaryOperator::Create(SemaRef.Context, LHS.get(), RHS.get(),
+                                    E->getOpcode(), SemaRef.Context.BoolTy,
+                                    VK_PRValue, OK_Ordinary,
+                                    E->getOperatorLoc(), FPOptionsOverride{});
+    }
+
+    ExprResult TransformUnresolvedLookupExpr(UnresolvedLookupExpr *E, bool IsAddressOfOperand = false) {
+      if (E->isConceptReference() || E->isVarDeclReference()) {
+        TemplateInstantiator Instantiator(SemaRef, MLTAL,
+                                          SourceLocation(),
+                                          DeclarationName());
+        return Instantiator.TransformUnresolvedLookupExpr(E, IsAddressOfOperand);
+      }
+      return E;
+    }
+
+    bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
+                                   TemplateArgumentLoc &Output,
+                                   bool Uneval = false) {
+      if (Input.getArgument().isConceptOrConceptTemplateParameter()) {
+        TemplateInstantiator Instantiator(SemaRef, MLTAL,
+                                          SourceLocation(),
+                                          DeclarationName());
+        return Instantiator.TransformTemplateArgument(Input, Output, Uneval);
+      }
+
+      Output = Input;
+      return false;
+    }
+  };
+
+  ConstraintExprTransformer Transformer(*this, MLTALForConstraint);
+  ExprResult Res =
+      Transformer.TransformExpr(const_cast<Expr *>(ConstraintExpr));
+  return Res;
+}
+
 ExprResult
 Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
   if (!E)
@@ -4356,6 +4706,15 @@ Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
   return Instantiator.TransformTemplateName(SS, Name, Loc);
 }
 
+NamedDecl *Sema::SubstUniversalTemplateParameter(
+    UniversalTemplateParmDecl *D,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    unsigned SubstitutedLevels) {
+  TemplateInstantiator Instantiator(*this, TemplateArgs, D->getLocation(),
+                                    D->getDeclName());
+  return Instantiator.TransformUniversalTemplateParameter(D, SubstitutedLevels);
+}
+
 static const Decl *getCanonicalParmVarDecl(const Decl *D) {
   // When storing ParmVarDecls in the local instantiation scope, we always
   // want to use the ParmVarDecl from the canonical function declaration,
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index e055c87e78381..d3ea3a0f1301a 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -3281,14 +3281,16 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
     Param = TemplateTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
-        D->getPosition(), D->getIdentifier(), D->wasDeclaredWithTypename(),
-        InstParams, ExpandedParams);
+        D->getPosition(), D->getIdentifier(), D->kind(), D->wasDeclaredWithTypename(),
+        InstParams,
+        ExpandedParams);
   else
     Param = TemplateTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
         D->getPosition(), D->isParameterPack(), D->getIdentifier(),
-        D->wasDeclaredWithTypename(), InstParams);
+        D->kind(), D->wasDeclaredWithTypename(),
+        InstParams);
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     NestedNameSpecifierLoc QualifierLoc =
         D->getDefaultArgument().getTemplateQualifierLoc();
@@ -3314,6 +3316,22 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl(
   return Param;
 }
 
+Decl *TemplateDeclInstantiator::VisitUniversalTemplateParmDecl(
+    UniversalTemplateParmDecl *D) {
+
+  LocalInstantiationScope Scope(SemaRef);
+  Decl *Transformed = SemaRef.SubstUniversalTemplateParameter(
+      D, TemplateArgs, TemplateArgs.getNumSubstitutedLevels());
+  if (!Transformed)
+    return nullptr;
+  Transformed->setAccess(AS_public);
+  Transformed->setImplicit(D->isImplicit());
+  // Introduce this template parameter's instantiation into the instantiation
+  // scope.
+  SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Transformed);
+  return Transformed;
+}
+
 Decl *TemplateDeclInstantiator::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
   // Using directives are never dependent (and never contain any types or
   // expressions), so they require no explicit instantiation work.
diff --git a/clang/lib/Sema/SemaTemplateVariadic.cpp b/clang/lib/Sema/SemaTemplateVariadic.cpp
index 40522a07f6339..34d75007192c0 100644
--- a/clang/lib/Sema/SemaTemplateVariadic.cpp
+++ b/clang/lib/Sema/SemaTemplateVariadic.cpp
@@ -8,14 +8,16 @@
 //  This file implements semantic analysis for C++0x variadic templates.
 //===----------------------------------------------------------------------===/
 
-#include "clang/Sema/Sema.h"
 #include "TypeLocBuilder.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include <optional>
@@ -116,6 +118,15 @@ namespace {
       return inherited::TraverseTemplateName(Template);
     }
 
+    /// Record occurrences of template template parameter packs.
+    bool TraverseUniversalTemplateParameterName(
+        UniversalTemplateParameterName *UTPN) {
+      UniversalTemplateParmDecl *D = UTPN->getDecl();
+      if (D->isParameterPack())
+        Unexpanded.push_back({D, UTPN->getLocation()});
+      return inherited::TraverseUniversalTemplateParameterName(UTPN);
+    }
+
     /// Suppress traversal into Objective-C container literal
     /// elements that are pack expansions.
     bool TraverseObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
@@ -285,6 +296,16 @@ namespace {
       return inherited::TraverseLambdaCapture(Lambda, C, Init);
     }
 
+    bool TraverseUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
+      if (E->getNumDecls() == 1) {
+        NamedDecl *ND = *E->decls_begin();
+        if (auto *TTP = llvm::dyn_cast<TemplateTemplateParmDecl>(ND);
+            TTP && TTP->isParameterPack())
+          addUnexpanded(ND, E->getBeginLoc());
+      }
+      return inherited::TraverseUnresolvedLookupExpr(E);
+    }
+
 #ifndef NDEBUG
     bool TraverseFunctionParmPackExpr(FunctionParmPackExpr *) {
       ContainsFunctionParmPackExpr = true;
@@ -625,9 +646,21 @@ Sema::ActOnPackExpansion(const ParsedTemplateArgument &Arg,
         << R;
       return ParsedTemplateArgument();
     }
+    return Arg.getTemplatePackExpansion(EllipsisLoc);
 
+  case ParsedTemplateArgument::Universal:
+    if (!Arg.getAsUniversalTemplateParamName()
+             .get()
+             ->containsUnexpandedParameterPack()) {
+      SourceRange R(Arg.getLocation());
+      if (Arg.getScopeSpec().isValid())
+        R.setBegin(Arg.getScopeSpec().getBeginLoc());
+      Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs) << R;
+      return ParsedTemplateArgument();
+    }
     return Arg.getTemplatePackExpansion(EllipsisLoc);
   }
+
   llvm_unreachable("Unhandled template argument kind?");
 }
 
@@ -1198,9 +1231,17 @@ TemplateArgumentLoc Sema::getTemplateArgumentPackExpansionPattern(
                                OrigLoc.getTemplateQualifierLoc(),
                                OrigLoc.getTemplateNameLoc());
 
+  case TemplateArgument::UniversalExpansion:
+    Ellipsis = OrigLoc.getUniversalEllipsisLoc();
+    NumExpansions = Argument.getNumTemplateExpansions();
+    return TemplateArgumentLoc(Context, Argument.getPackExpansionPattern(),
+                               Argument.getPackExpansionPattern()
+                                   .getAsUniversalTemplateParameterOrPattern());
+
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::Template:
+  case TemplateArgument::Universal:
   case TemplateArgument::Integral:
   case TemplateArgument::StructuralValue:
   case TemplateArgument::Pack:
@@ -1252,6 +1293,7 @@ std::optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
   case TemplateArgument::Declaration:
   case TemplateArgument::NullPtr:
   case TemplateArgument::TemplateExpansion:
+  case TemplateArgument::UniversalExpansion:
   case TemplateArgument::Integral:
   case TemplateArgument::StructuralValue:
   case TemplateArgument::Pack:
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 950bd6db0359d..d5b636423253b 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -1310,12 +1310,12 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
                       ? AutoTypeKeyword::DecltypeAuto
                       : AutoTypeKeyword::Auto;
 
-    ConceptDecl *TypeConstraintConcept = nullptr;
+    TemplateDecl *TypeConstraintConcept = nullptr;
     llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
     if (DS.isConstrainedAuto()) {
       if (TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId()) {
         TypeConstraintConcept =
-            cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl());
+            cast<TemplateDecl>(TemplateId->Template.get().getAsTemplateDecl());
         TemplateArgumentListInfo TemplateArgsInfo;
         TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
         TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
@@ -3068,9 +3068,8 @@ InventTemplateParameter(TypeProcessingState &state, QualType T,
             D.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.Context),
             DeclarationNameInfo(DeclarationName(TemplateId->Name),
                                 TemplateId->TemplateNameLoc),
-            CD,
-            /*FoundDecl=*/
-            USD ? cast<NamedDecl>(USD) : CD,
+            cast<TemplateDecl>(TemplateId->Template.get().getAsTemplateDecl()),
+            /*FoundDecl=*/USD ? cast<NamedDecl>(USD) : CD,
             TemplateId->LAngleLoc.isValid() ? &TemplateArgsInfo : nullptr,
             InventedTemplateParam, D.getEllipsisLoc());
       }
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 95ded5e59a9fa..174ebf067a6be 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -16,8 +16,10 @@
 #include "CoroutineStmtBuilder.h"
 #include "TypeLocBuilder.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprConcepts.h"
@@ -29,8 +31,13 @@
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/StmtOpenACC.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/UniversalTemplateParameterName.h"
 #include "clang/Basic/DiagnosticParse.h"
 #include "clang/Basic/OpenMPKinds.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/Designator.h"
 #include "clang/Sema/EnterExpressionEvaluationContext.h"
 #include "clang/Sema/Lookup.h"
@@ -45,6 +52,7 @@
 #include "clang/Sema/SemaPseudoObject.h"
 #include "clang/Sema/SemaSYCL.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <algorithm>
 #include <optional>
@@ -608,6 +616,13 @@ class TreeTransform {
                                  TemplateArgumentLoc &Output,
                                  bool Uneval = false);
 
+  TemplateArgument
+  TransformNamedTemplateTemplateArgument(CXXScopeSpec &SS, TemplateName Name,
+                                         SourceLocation NameLoc);
+
+  TemplateArgument
+  TransformUniversalTemplateArgument(UniversalTemplateParameterName *Name);
+
   /// Transform the given set of template arguments.
   ///
   /// By default, this operation transforms all of the template arguments
@@ -634,6 +649,11 @@ class TreeTransform {
                                       Uneval);
   }
 
+  bool InjectAdditionalArgumentsFromPartiallyAppliedConcept(
+      TemplateArgumentListInfo &, TemplateDecl *) {
+    return true;
+  }
+
   /// Transform the given set of template arguments.
   ///
   /// By default, this operation transforms all of the template arguments
@@ -654,6 +674,12 @@ class TreeTransform {
                                   TemplateArgumentListInfo &Outputs,
                                   bool Uneval = false);
 
+  template <typename InputIterator>
+  bool TransformConceptTemplateArguments(InputIterator First,
+                                         InputIterator Last,
+                                         TemplateArgumentListInfo &Outputs,
+                                         bool Uneval = false);
+
   /// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
   void InventTemplateArgumentLoc(const TemplateArgument &Arg,
                                  TemplateArgumentLoc &ArgLoc);
@@ -3986,13 +4012,24 @@ class TreeTransform {
           Pattern.getTemplateQualifierLoc(), Pattern.getTemplateNameLoc(),
           EllipsisLoc);
 
+    case TemplateArgument::Universal:
+      return TemplateArgumentLoc(
+          SemaRef.Context,
+          TemplateArgument(
+              Pattern.getArgument().getAsUniversalTemplateParameterName(),
+              NumExpansions),
+          Pattern.getArgument().getAsUniversalTemplateParameterName(),
+          EllipsisLoc);
+
     case TemplateArgument::Null:
     case TemplateArgument::Integral:
     case TemplateArgument::Declaration:
     case TemplateArgument::StructuralValue:
     case TemplateArgument::Pack:
+    case TemplateArgument::UniversalExpansion:
     case TemplateArgument::TemplateExpansion:
     case TemplateArgument::NullPtr:
+    case TemplateArgument::Concept:
       llvm_unreachable("Pack expansion pattern has no parameter packs");
 
     case TemplateArgument::Type:
@@ -4684,6 +4721,33 @@ TreeTransform<Derived>::TransformTemplateName(CXXScopeSpec &SS,
   llvm_unreachable("overloaded function decl survived to here");
 }
 
+template <typename Derived>
+TemplateArgument TreeTransform<Derived>::TransformNamedTemplateTemplateArgument(
+    CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc) {
+  TemplateName TN = getDerived().TransformTemplateName(SS, Name, NameLoc);
+  if (TN.isNull())
+    return TemplateArgument();
+  return TemplateArgument(TN);
+}
+
+template <typename Derived>
+TemplateArgument TreeTransform<Derived>::TransformUniversalTemplateArgument(
+    UniversalTemplateParameterName *Name) {
+  DeclarationNameInfo NameInfo = Name->getNameInfo();
+  if (NameInfo.getName()) {
+    NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
+    if (!NameInfo.getName())
+      return TemplateArgument();
+  }
+  Decl *D = TransformDecl(Name->getDecl()->getLocation(), Name->getDecl());
+  if (!D)
+    return TemplateArgument();
+
+  return TemplateArgument(
+      getSema().getASTContext().getUniversalTemplateParameterName(
+          Name->getLocation(), NameInfo, cast<UniversalTemplateParmDecl>(D)));
+}
+
 template<typename Derived>
 void TreeTransform<Derived>::InventTemplateArgumentLoc(
                                          const TemplateArgument &Arg,
@@ -4768,16 +4832,62 @@ bool TreeTransform<Derived>::TransformTemplateArgument(
 
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
-    TemplateName Template = getDerived().TransformTemplateName(
+
+    TemplateArgument Out = getDerived().TransformNamedTemplateTemplateArgument(
         SS, Arg.getAsTemplate(), Input.getTemplateNameLoc());
-    if (Template.isNull())
+    if (Out.isNull())
+      return true;
+    Output = TemplateArgumentLoc(SemaRef.Context, Out, QualifierLoc,
+                                 Input.getTemplateNameLoc());
+    return false;
+  }
+
+  case TemplateArgument::Concept: {
+    PartiallyAppliedConcept *C = Arg.getAsPartiallyAppliedConcept();
+    TemplateDecl *T = cast_or_null<TemplateDecl>(getDerived().TransformDecl(
+        C->getConceptNameLoc(), C->getNamedConcept()));
+    if (!T)
+      return true;
+    DeclarationNameInfo NameInfo = C->getConceptNameInfo();
+    if (NameInfo.getName()) {
+      NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
+      if (!NameInfo.getName())
+        return true;
+    }
+
+    TemplateArgumentListInfo NewTemplateArgs;
+    getDerived().TransformTemplateArguments(
+        C->getTemplateArgsAsWritten()->getTemplateArgs(),
+        C->getTemplateArgsAsWritten()->getNumTemplateArgs(), NewTemplateArgs);
+
+    PartiallyAppliedConcept *Transformed = SemaRef.BuildPartiallyAppliedConcept(
+        C->getNestedNameSpecifierLoc(), C->getConceptKWLoc(), NameInfo, T,
+        NewTemplateArgs);
+    if (!Transformed)
       return true;
 
-    Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Template),
-                                 QualifierLoc, Input.getTemplateNameLoc());
+    Output = TemplateArgumentLoc(SemaRef.Context, TemplateArgument(Transformed),
+                                 C->getNestedNameSpecifierLoc(),
+                                 NameInfo.getLoc(), SourceLocation());
+    return false;
+  }
+
+  case TemplateArgument::Universal: {
+    UniversalTemplateParameterName *N =
+        Arg.getAsUniversalTemplateParameterName();
+    TemplateArgument Out = getDerived().TransformUniversalTemplateArgument(N);
+    if (Out.isNull())
+      return true;
+    Output = SemaRef.getTrivialTemplateArgumentLoc(Out, QualType(),
+                                                   N->getLocation());
+    if (Out.getKind() != TemplateArgument::Universal) {
+      TemplateArgumentLoc Copy = Output;
+      return getDerived().TransformTemplateArgument(Copy, Output);
+    }
     return false;
   }
 
+  case TemplateArgument::UniversalExpansion:
   case TemplateArgument::TemplateExpansion:
     llvm_unreachable("Caller should expand pack expansions");
 
@@ -4801,6 +4911,8 @@ bool TreeTransform<Derived>::TransformTemplateArgument(
     Output = TemplateArgumentLoc(TemplateArgument(E.get()), E.get());
     return false;
   }
+  default:
+    llvm_unreachable("Unhandled template argument kind");
   }
 
   // Work around bogus GCC warning
@@ -4984,6 +5096,56 @@ bool TreeTransform<Derived>::TransformTemplateArguments(
 
 }
 
+template <typename Derived>
+template <typename InputIterator>
+bool TreeTransform<Derived>::TransformConceptTemplateArguments(
+    InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
+    bool Uneval) {
+
+  auto isConcept = [](const TemplateArgument &Arg) {
+    bool isConcept = Arg.getKind() == TemplateArgument::Concept;
+    if (!isConcept && Arg.getKind() == TemplateArgument::Template)
+      if (auto *TTP = dyn_cast_if_present<TemplateTemplateParmDecl>(
+              Arg.getAsTemplate().getAsTemplateDecl()))
+        isConcept = TTP->kind() == TNK_Concept_template;
+    return isConcept;
+  };
+
+  for (; First != Last; ++First) {
+    TemplateArgumentLoc Out;
+    TemplateArgumentLoc In = *First;
+
+    if (In.getArgument().getKind() == TemplateArgument::Pack) {
+      // if(In.getArgument().pack_size() == 00  ||
+      // !isConcept(In.getArgument().pack_elements()[0])) {
+      //   Outputs.addArgument(In);
+      //   continue;
+      // }
+      typedef TemplateArgumentLocInventIterator<Derived,
+                                                TemplateArgument::pack_iterator>
+          PackLocIterator;
+      if (TransformConceptTemplateArguments(
+              PackLocIterator(*this, In.getArgument().pack_begin()),
+              PackLocIterator(*this, In.getArgument().pack_end()), Outputs,
+              Uneval))
+        return true;
+      continue;
+    }
+
+    if (!isConcept(In.getArgument())) {
+      Outputs.addArgument(In);
+      continue;
+    }
+
+    if (getDerived().TransformTemplateArgument(In, Out, Uneval))
+      return true;
+
+    Outputs.addArgument(Out);
+  }
+
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // Type transformation
 //===----------------------------------------------------------------------===//
@@ -13904,6 +14066,11 @@ TreeTransform<Derived>::TransformUnresolvedLookupExpr(UnresolvedLookupExpr *Old,
     return ExprError();
   }
 
+  if (Old->isConceptReference()) {
+    getDerived().InjectAdditionalArgumentsFromPartiallyAppliedConcept(
+        TransArgs, Old->getTemplateDecl());
+  }
+
   // An UnresolvedLookupExpr can refer to a class member. This occurs e.g. when
   // a non-static data member is named in an unevaluated operand, or when
   // a member is named in a dependent class scope function template explicit
diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp
index 84743a52d4c8b..f5511cc464ba5 100644
--- a/clang/lib/Serialization/ASTReaderStmt.cpp
+++ b/clang/lib/Serialization/ASTReaderStmt.cpp
@@ -2067,13 +2067,12 @@ void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
   assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
          "Wrong HasTemplateKWAndArgsInfo!");
 
+  unsigned NumTemplateArgs = 0;
   if (HasTemplateKWAndArgsInfo) {
-    unsigned NumTemplateArgs = Record.readInt();
+    NumTemplateArgs = Record.readInt();
     ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
                               E->getTrailingTemplateArgumentLoc(),
                               NumTemplateArgs);
-    assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
-           "Wrong NumTemplateArgs!");
   }
 
   UnresolvedSet<8> Decls;
@@ -2089,6 +2088,9 @@ void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
     Results[I] = (Iter + I).getPair();
   }
 
+  assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
+         "Wrong NumTemplateArgs!");
+
   E->NameInfo = Record.readDeclarationNameInfo();
   E->QualifierLoc = Record.readNestedNameSpecifierLoc();
 }
diff --git a/clang/test/CodeGenCXX/mangle-concept.cpp b/clang/test/CodeGenCXX/mangle-concept.cpp
index e9c46d87635ab..aafaee4119ae3 100644
--- a/clang/test/CodeGenCXX/mangle-concept.cpp
+++ b/clang/test/CodeGenCXX/mangle-concept.cpp
@@ -5,7 +5,8 @@
 namespace test1 {
 template <bool> struct S {};
 template <typename> concept C = true;
-template <typename T = int> S<C<T>> f0() { return S<C<T>>{}; }
+template <typename T = int>
+S<C<T>> f0() { return S<C<T>>{}; }
 template S<C<int>> f0<>();
 // CHECK: @_ZN5test12f0IiEENS_1SIX1CIT_EEEEv(
 // CLANG16: @_ZN5test12f0IiEENS_1SIL_ZNS_1CIT_EEEEEv(
diff --git a/clang/test/Parser/cxx-template-template-recovery.cpp b/clang/test/Parser/cxx-template-template-recovery.cpp
index 5700b160cd364..a7f5c2e4adf5e 100644
--- a/clang/test/Parser/cxx-template-template-recovery.cpp
+++ b/clang/test/Parser/cxx-template-template-recovery.cpp
@@ -22,18 +22,18 @@ auto V3 = true; // #V3
 template <template <typename T> typename C>
 constexpr bool test = true;
 
-static_assert(test<a::C1>); // expected-error {{too few template arguments for concept 'C1'}} \
+static_assert(test<a::C1>); // expected-error {{template argument does not refer to a class or alias template, or template template parameter}} \
                             // expected-note@#C1 {{here}}
-static_assert(test<a::b::C2>); // expected-error {{too few template arguments for concept 'C2'}} \
+static_assert(test<a::b::C2>); // expected-error {{template argument does not refer to a class or alias template, or template template parameter}} \
                                // expected-note@#C2 {{here}}
-static_assert(test<C3>); // expected-error {{too few template arguments for concept 'C3'}} \
+static_assert(test<C3>); // expected-error {{template argument does not refer to a class or alias template, or template template parameter}} \
                          // expected-note@#C3 {{here}}
 
 static_assert(test<a::V1>); // expected-error {{use of variable template 'a::V1' requires template arguments}} \
                             // expected-note@#V1 {{here}}
 static_assert(test<a::b::V2>); // expected-error {{use of variable template 'a::b::V2' requires template arguments}} \
                             // expected-note@#V2 {{here}}
-static_assert(test<V3>); // expected-error {{use of variable template 'V3' requires template arguments}} \
+static_assert(test<V3>); // expected-error {{template argument does not refer to a class or alias template, or template template parameter}} \
                          // expected-note@#V3 {{here}}
 
 
diff --git a/clang/test/Parser/cxx2a-concept-declaration.cpp b/clang/test/Parser/cxx2a-concept-declaration.cpp
index 0a7af847112de..fea6084d58f3a 100644
--- a/clang/test/Parser/cxx2a-concept-declaration.cpp
+++ b/clang/test/Parser/cxx2a-concept-declaration.cpp
@@ -9,11 +9,6 @@ template<concept T> concept D1 = true;
 // expected-error@-1{{expected template parameter}}
 // expected-error@-2{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
 
-template<template<typename> concept T> concept D2 = true;
-// expected-error@-1{{expected identifier}}
-// expected-error@-2{{template template parameter requires 'class' or 'typename' after the parameter list}}
-// expected-error@-3{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
-
 struct S1 {
   template<typename T> concept C1 = true; // expected-error {{concept declarations may only appear in global or namespace scope}}
 };
diff --git a/clang/test/Parser/cxx2c-template-template-param.cpp b/clang/test/Parser/cxx2c-template-template-param.cpp
new file mode 100644
index 0000000000000..aa9e2393cf106
--- /dev/null
+++ b/clang/test/Parser/cxx2c-template-template-param.cpp
@@ -0,0 +1,79 @@
+// RUN:  %clang_cc1 -std=c++2b -verify %s
+
+template<template<typename> auto Var>
+struct A{};
+template<template<auto> auto Var>
+struct B{};
+template<template<typename> auto Var>
+struct C{};
+template<template<typename> concept C>
+struct D{};
+template<template<auto> concept C>
+struct E{};
+
+template<template<typename> auto Var>
+int V1;
+template<template<auto> auto Var>
+int V2;
+template<template<typename> auto Var>
+int V3;
+template<template<typename> concept C>
+int V4;
+template<template<auto> concept C>
+int V5;
+
+namespace packs {
+
+template<template<typename> auto... Var>
+struct A{};
+template<template<auto> auto... Var>
+struct B{};
+template<template<typename> auto... Var>
+struct C{};
+template<template<typename> concept... C>
+struct D{};
+template<template<auto> concept... C>
+struct E{};
+
+template<template<typename> auto... Var>
+int V1;
+template<template<auto> auto...  Var>
+int V2;
+template<template<typename> auto...  Var>
+int V3;
+template<template<typename> concept... C>
+int V4;
+template<template<auto> concept... C>
+int V5;
+
+}
+
+namespace concepts {
+template<template<auto> concept...>
+struct A{};
+template<template<auto> concept... C>
+struct B{};
+template<template<auto> concept& C> // expected-error{{expected identifier}} \
+                                    // expected-error {{in declaration of struct 'C'}}
+struct C{};
+}
+
+namespace vars {
+template<template<auto> auto...>
+struct A{};
+template<template<auto> auto & C> // expected-error {{expected identifier}} \
+                                  // expected-error {{extraneous 'template<>'}}
+struct B{};
+template<template<auto> const auto> // expected-error {{expected identifier}} \
+                                    // expected-error {{extraneous 'template<>'}}
+struct C{};
+}
+
+namespace errors {
+template<concept> // expected-error {{expected template parameter}} \
+                  // expected-error {{extraneous 'template<>' in declaration of struct 'A'}}
+struct A{};
+template<template<concept> auto> // expected-error {{expected template parameter}} \
+                                 // expected-error {{template template parameter must have its own template parameters}}
+struct B{};
+}
diff --git a/clang/test/Sema/cxx2c-partially-applied-concepts.cpp b/clang/test/Sema/cxx2c-partially-applied-concepts.cpp
new file mode 100644
index 0000000000000..15f67888552ea
--- /dev/null
+++ b/clang/test/Sema/cxx2c-partially-applied-concepts.cpp
@@ -0,0 +1,38 @@
+// RUN:  %clang_cc1 -std=c++2b -verify %s
+
+template <typename C, typename>
+concept Concept = true; // expected-note 2{{template is declared here}}
+
+template <template <typename> concept C>
+struct S {
+};
+
+template <typename>
+struct NotAConcept {};
+
+S<concept Concept<int>> s;
+S<concept Concept<int, int>> s; // expected-error {{too many template arguments for concept 'Concept'}}
+S<concept Concept<>> s; // expected-error {{too few template arguments for concept 'Concept'}}
+
+
+
+S<concept Concept<1>> s2;
+S<concept NotAConcept<int>> s3; // expected-error {{name of template argument does not refer to concept, or concept template parameter}} \
+                                // expected-error {{expected expression}}
+namespace BasicOverloading {
+
+template <template <typename...T> concept C>
+void f();
+
+template <bool b>
+void f();
+
+template <typename...>
+concept C = true;
+
+void test() {
+    f<C<int>>();
+    f<concept C<int>>();
+}
+
+}
diff --git a/clang/test/SemaCXX/cxx2c-template-template-param.cpp b/clang/test/SemaCXX/cxx2c-template-template-param.cpp
new file mode 100644
index 0000000000000..b96ce733eabe0
--- /dev/null
+++ b/clang/test/SemaCXX/cxx2c-template-template-param.cpp
@@ -0,0 +1,372 @@
+// RUN:  %clang_cc1 -std=c++2b -verify %s
+
+namespace Errors {
+
+template <template<typename T> auto>
+struct S1;
+template <template<auto T> auto>
+struct S2;
+template <template<typename T> concept>
+struct S3;
+template <template<auto T> concept>
+struct S4;
+int a;
+
+template <typename T>
+concept C = true; // expected-note 2{{template argument refers to a concept 'C', here}}
+template <typename T>
+auto Var = 0; // expected-note 2{{template argument refers to a variable template 'Var', here}}
+
+S1<1> t1; // expected-error {{template argument for template template parameter must be a variable template}}
+S1<a> t2; // expected-error {{template argument for template template parameter must be a variable template}}
+S1<int> t3; // expected-error {{template argument for template template parameter must be a variable template}}
+S1<C> t4; // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+S2<1> t5; // expected-error {{template argument for template template parameter must be a variable template}}
+S2<a> t6; // expected-error {{template argument for template template parameter must be a variable template}}
+S2<int> t7; // expected-error {{template argument for template template parameter must be a variable template}}
+S2<C> t8; // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+S3<1> t9; // expected-error {{template argument for template template parameter must be a concept}}
+S3<a> t10; // expected-error {{template argument for template template parameter must be a concept}}
+S3<int> t11; // expected-error {{template argument for template template parameter must be a concept}}
+S3<Var> t12; // expected-error {{template argument does not refer to a concept, or template template parameter}}
+S4<1> t13; // expected-error {{template argument for template template parameter must be a concept}}
+S4<a> t14; // expected-error {{template argument for template template parameter must be a concept}}
+S4<int> t15; // expected-error {{template argument for template template parameter must be a concept}}
+S4<Var> t16; // expected-error {{template argument does not refer to a concept, or template template parameter}}
+
+}
+
+template <template<typename T> auto V> // expected-note {{previous template template parameter is here}}
+struct S1 {
+    static_assert(V<int> == 42);
+    static_assert(V<const int> == 84);
+    static_assert(V<double> == 0);
+};
+template <template<auto T> auto V>  // expected-note {{previous template template parameter is here}}
+struct S2 {
+    static_assert(V<0> == 1);
+    static_assert(V<1> == 0);
+};
+template <template<typename T> concept C > // expected-note {{previous template template parameter is here}}
+struct S3 {
+    static_assert(C<int>);
+};
+template <template<auto> concept C> // expected-note {{previous template template parameter is here}}
+struct S4 {
+    static_assert(C<0>);
+};
+
+template <typename T> // expected-note {{template parameter has a different kind in template argument}}
+concept C = true;
+
+template <auto I> // expected-note {{template parameter has a different kind in template argument}}
+concept CI = true;
+
+template <typename T> // expected-note {{template parameter has a different kind in template argument}}
+constexpr auto Var = 42;
+template <typename T>
+constexpr auto Var<const T> = 84;
+template <>
+constexpr auto Var<double> = 0;
+
+template <auto N> // expected-note {{template parameter has a different kind in template argument}}
+constexpr auto Var2 = 0;
+template <auto N>
+requires (N%2 == 0)
+constexpr auto Var2<N> = 1;
+
+void test () {
+    S1<Var2> sE; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+    S2<Var>  sE; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+    S1<Var> s1;
+    S2<Var2> s2;
+    S3<C> s3;
+    S4<C> sE; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+    S4<CI> s4;
+    S3<CI> sE; // expected-error {{template template argument has different template parameters than its corresponding template template parameter}}
+}
+
+namespace subsumption {
+
+template <typename T>
+concept A = true;
+
+template <typename T>
+concept B = A<T> && true;
+
+template <typename T>
+concept C = true;
+
+template <typename T>
+concept D = C<T> && true;
+
+template <typename ABC, template <typename> concept... C>
+concept Apply = (C<ABC> && ...);
+
+constexpr int f(Apply<A, C> auto) {return 1;}
+constexpr int f(Apply<B, D> auto) {return 2;}
+
+int test() {
+   static_assert(f(1) == 2);
+}
+
+}
+
+namespace template_type_constraints {
+
+
+template <typename T>
+concept Unary = true;
+template <typename T, typename = int>
+concept BinaryDefaulted = true;
+
+template <typename T>
+concept UnaryFalse = false; // expected-note 3{{because 'false' evaluated to false}}
+template <typename T, typename = int>
+concept BinaryDefaultedFalse = false;
+
+template <template <typename...> concept C, typename T>
+struct S {
+    template <C TT> // expected-note {{because 'int' does not satisfy 'UnaryFalse'}}
+    void f(TT); // expected-note {{ignored}}
+    void g(C auto); // expected-note {{ignored}} \
+                    // expected-note {{because 'int' does not satisfy 'UnaryFalse'}}
+
+    auto h() -> C auto { // expected-error {{deduced type 'int' does not satisfy 'UnaryFalse'}}
+        return 0;
+    };
+
+    void test() {
+        C auto a = 0;
+    }
+};
+
+template <template <typename...> concept C, typename T>
+struct SArg {
+    template <C<int> TT>
+    void f(TT);
+    void g(C<int> auto);
+
+    auto h() -> C<int> auto {
+        return 0;
+    };
+    void test() {
+        C<int> auto a = 0;
+    }
+};
+
+void test() {
+    S<Unary, int> s;
+    s.f(0);
+    s.g(0);
+    s.h();
+    S<BinaryDefaulted, int> s2;
+    s2.f(0);
+    s2.g(0);
+    s2.h();
+
+    SArg<BinaryDefaulted, int> s3;
+    s3.f(0);
+    s3.g(0);
+    s3.h();
+}
+
+void test_errors() {
+    S<UnaryFalse, int> s;
+    s.f(0); // expected-error {{no matching member function for call to 'f'}}
+    s.g(0); // expected-error {{no matching member function for call to 'g'}}
+    s.h(); // expected-note {{in instantiation of member function 'template_type_constraints::S<template_type_constraints::UnaryFalse, int>::h'}}
+}
+
+}
+
+template <typename T>
+concept Unary = true;
+template <typename T, typename = int>
+concept BinaryDefaulted = true;
+
+template <typename T>
+concept UnaryFalse = false; // expected-note 3{{because 'false' evaluated to false}}
+template <typename T, typename = int>
+concept BinaryDefaultedFalse = false;
+
+template <template <typename...> concept C, typename T>
+struct S {
+    template <C TT> // expected-note {{because 'int' does not satisfy 'UnaryFalse'}}
+    void f(TT); // expected-note {{ignored}}
+    void g(C auto); // expected-note {{ignored}} \
+                    // expected-note {{because 'int' does not satisfy 'UnaryFalse'}}
+
+    auto h() -> C auto { // expected-error {{deduced type 'int' does not satisfy 'UnaryFalse'}}
+        return 0;
+    };
+
+    void test() {
+        C auto a = 0;
+    }
+};
+
+template <template <typename...> concept C, typename T>
+struct SArg {
+    template <C<int> TT>
+    void f(TT);
+    void g(C<int> auto);
+
+    auto h() -> C<int> auto {
+        return 0;
+    };
+    void test() {
+        C<int> auto a = 0;
+    }
+};
+
+void test_args() {
+    S<Unary, int> s;
+    s.f(0);
+    s.g(0);
+    s.h();
+    S<BinaryDefaulted, int> s2;
+    s2.f(0);
+    s2.g(0);
+    s2.h();
+
+    SArg<BinaryDefaulted, int> s3;
+    s3.f(0);
+    s3.g(0);
+    s3.h();
+}
+
+void test_errors() {
+    S<UnaryFalse, int> s;
+    s.f(0); // expected-error {{no matching member function for call to 'f'}}
+    s.g(0); // expected-error {{no matching member function for call to 'g'}}
+    s.h(); // expected-note {{in instantiation of member function 'S<UnaryFalse, int>::h'}}
+}
+
+namespace non_type {
+
+template <auto>
+concept Unary = true;
+
+template <template <auto> concept C>
+struct S {
+    template <C Foo> // expected-error {{concept named in type constraint is not a type concept}}
+    void f();
+    // FIXME, bad diagnostic
+    void g(C auto);  // expected-error{{concept named in type constraint is not a type concept}}
+    auto h() -> C auto {  // expected-error{{concept named in type constraint is not a type concept}}
+    }
+    void i() {
+        C auto a = 0;  // expected-error{{concept named in type constraint is not a type concept}}
+    }
+};
+
+}
+
+namespace default_args {
+
+template <typename T>
+concept Concept = false; // expected-note 2{{template argument refers to a concept 'Concept', here}} \
+                         // expected-note 2{{because 'false' evaluated to false}}
+
+template <typename T>
+constexpr auto Var = false; // expected-note 2{{template argument refers to a variable template 'Var', here}}
+
+template <typename T>
+struct Type; // expected-note 2{{template argument refers to a class template 'Type', here}}
+
+
+template <template <typename> auto = Concept> // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+struct E1;
+
+template <template <typename> auto  = Type> // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+struct E2;
+
+template <template <typename> typename = Concept> // expected-error {{template argument does not refer to a class or alias template, or template template parameter}}
+struct E3;
+
+template <template <typename> typename  = Var> // expected-error {{template argument does not refer to a class or alias template, or template template parameter}}
+struct E4;
+
+template <template <typename> concept  = Var> // expected-error {{template argument does not refer to a concept, or template template parameter}}
+struct E4;
+
+template <template <typename> concept  = Type> // expected-error {{template argument does not refer to a concept, or template template parameter}}
+struct E4;
+
+template <
+    template <typename> concept TConcept, // expected-note 2{{template argument refers to a concept 'TConcept', here}}
+    template <typename> auto TVar, // expected-note 2{{template argument refers to a variable template 'TVar', here}}
+    template <typename> typename TType // expected-note 2{{template argument refers to a class template 'TType', here}}
+>
+struct Nested {
+    template <template <typename> auto = TConcept> // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+    struct E1;
+
+    template <template <typename> auto  = TType> // expected-error {{template argument does not refer to a variable template, or template template parameter}}
+    struct E2;
+
+    template <template <typename> typename = TConcept> // expected-error {{template argument does not refer to a class or alias template, or template template parameter}}
+    struct E3;
+
+    template <template <typename> typename  = TVar> // expected-error {{template argument does not refer to a class or alias template, or template template parameter}}
+    struct E4;
+
+    template <template <typename> concept  = TVar> // expected-error {{template argument does not refer to a concept, or template template parameter}}
+    struct E4;
+
+    template <template <typename> concept  = TType> // expected-error {{template argument does not refer to a concept, or template template parameter}}
+    struct E4;
+};
+
+
+template <template <typename> concept C = Concept>
+struct TestDefaultConcept {
+    template <template <typename> concept CC = C>
+    void f() {
+        static_assert(C<int>); // expected-error {{static assertion failed}} \
+                               // expected-note {{because 'int' does not satisfy 'Concept'}}
+        static_assert(CC<int>);  // expected-error {{static assertion failed}} \
+                                 // expected-note {{because 'int' does not satisfy 'Concept'}}
+    }
+};
+void do_test_concept() {
+    TestDefaultConcept<>{}.f(); // expected-note {{in instantiation}}
+}
+
+template <template <typename> auto V = Var>
+struct TestDefaultVar {
+    template <template <typename> auto VV = V>
+    void f() {
+        static_assert(V<int>); // expected-error {{static assertion failed}}
+        static_assert(VV<int>); // expected-error {{static assertion failed}}
+    }
+};
+void do_test_var() {
+    TestDefaultVar<>{}.f(); // expected-note {{in instantiation}}
+}
+
+}
+
+namespace TTPDependence {
+template <template <typename... > concept C>
+concept A = C<>;
+template <template <typename... > concept C>
+concept B = C<int>;
+
+template <template <typename... > auto Var>
+concept C = Var<>;
+template <template <typename... > auto Var>
+concept D = Var<int>;
+
+}
+
+namespace InvalidName {
+// FIXME corentin: improve diagnostics
+template <typename T, template <typename> concept C>
+concept A = C<T>; // expected-note {{here}}
+
+template <A<concept missing<int>> T> // expected-error {{expected expression}} \
+                                     // expected-error {{too few template arguments for concept 'A'}}
+auto f();
+}
diff --git a/clang/test/SemaTemplate/univeral.cpp b/clang/test/SemaTemplate/univeral.cpp
new file mode 100644
index 0000000000000..29bf0435847df
--- /dev/null
+++ b/clang/test/SemaTemplate/univeral.cpp
@@ -0,0 +1,184 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++2c
+
+namespace universal {
+
+constexpr int V = 0;
+struct S;
+
+template <typename T>
+int TV;
+template <auto T>
+int VV;
+template <universal template>
+int UV;
+template <typename T>
+struct TS;
+template <auto T>
+struct VS;
+template <universal template>
+struct US;
+
+template <typename T>
+concept TC = true;
+template <auto T>
+concept VC = true;
+template <universal template>
+concept UC = true;
+
+template <universal template T>
+inline constexpr bool is_typename_v = false;
+template <universal template U>
+inline constexpr bool is_nttp_v = false;
+template <universal template U>
+inline constexpr bool is_template_v = false;
+template <universal template U>
+inline constexpr bool is_type_template_v = false;
+template <universal template U>
+inline constexpr bool is_var_template_v = false;
+template <universal template U>
+inline constexpr bool is_concept_v = false;
+template <typename U>
+inline constexpr bool is_typename_v<U> = true;
+template <decltype(auto) U>
+inline constexpr bool is_nttp_v<U> = true;
+template <template<universal template> typename U>
+constexpr bool is_template_v<U> = true;
+template <template<universal template> auto U>
+constexpr bool is_template_v<U> = true;
+template <template<universal template> concept U>
+constexpr bool is_template_v<U> = true;
+template <template<universal template> typename U>
+inline constexpr bool is_type_template_v<U> = true;
+template <template<universal template> auto U>
+inline constexpr bool is_var_template_v<U> = true;
+template <template<universal template> concept U>
+inline constexpr bool is_concept_v<U> = true;
+
+static_assert(is_typename_v<int>);
+static_assert(is_typename_v<S>);
+static_assert(is_nttp_v<V>);
+static_assert(is_nttp_v<(V)>);
+static_assert(is_nttp_v<0>);
+
+static_assert(!is_template_v<int>);
+static_assert(!is_template_v<S>);
+static_assert(!is_template_v<V>);
+static_assert(!is_template_v<(V)>);
+static_assert(!is_template_v<0>);
+
+
+static_assert(is_template_v<TV>);
+static_assert(is_template_v<VV>);
+static_assert(is_template_v<UV>);
+static_assert(is_template_v<TS>);
+static_assert(is_template_v<VS>);
+static_assert(is_template_v<US>);
+static_assert(is_template_v<TC>);
+static_assert(is_template_v<VC>);
+static_assert(is_template_v<UC>);
+
+
+static_assert(is_var_template_v<TV>);
+static_assert(is_var_template_v<VV>);
+static_assert(is_var_template_v<UV>);
+static_assert(is_type_template_v<TS>);
+static_assert(is_type_template_v<VS>);
+static_assert(is_type_template_v<US>);
+static_assert(is_concept_v<TC>);
+static_assert(is_concept_v<VC>);
+static_assert(is_concept_v<UC>);
+
+
+static_assert(!is_var_template_v<int>);
+static_assert(!is_var_template_v<S>);
+static_assert(!is_var_template_v<V>);
+static_assert(!is_var_template_v<(V)>);
+static_assert(!is_var_template_v<0>);
+static_assert(!is_var_template_v<TC>);
+static_assert(!is_var_template_v<VC>);
+static_assert(!is_var_template_v<UC>);
+static_assert(!is_var_template_v<TS>);
+static_assert(!is_var_template_v<VS>);
+static_assert(!is_var_template_v<US>);
+
+static_assert(!is_concept_v<int>);
+static_assert(!is_concept_v<S>);
+static_assert(!is_concept_v<V>);
+static_assert(!is_concept_v<(V)>);
+static_assert(!is_concept_v<0>);
+static_assert(!is_concept_v<TV>);
+static_assert(!is_concept_v<VV>);
+static_assert(!is_concept_v<UV>);
+static_assert(!is_concept_v<TS>);
+static_assert(!is_concept_v<VS>);
+static_assert(!is_concept_v<US>);
+
+}
+
+namespace _typename {
+
+constexpr int V = 0;
+struct S;
+
+template <typename T>
+int TV;
+template <auto T>
+int VV;
+template <universal template>
+int UV;
+template <typename T>
+struct TS;
+template <auto T>
+struct VS;
+template <universal template>
+struct US;
+
+template <typename T>
+concept TC = true;
+template <auto T>
+concept VC = true;
+template <universal template>
+concept UC = true;
+
+template <universal template U>
+inline constexpr bool is_template_v = false;
+template <universal template U>
+inline constexpr bool is_type_template_v = false;
+template <universal template U>
+inline constexpr bool is_var_template_v = false;
+template <universal template U>
+inline constexpr bool is_concept_v = false;
+template <template<typename> typename U>
+constexpr bool is_template_v<U> = true;
+template <template<typename> auto U>
+constexpr bool is_template_v<U> = true;
+template <template<typename> concept U>
+constexpr bool is_template_v<U> = true;
+template <template<typename> typename U>
+inline constexpr bool is_type_template_v<U> = true;
+template <template<typename> auto U>
+inline constexpr bool is_var_template_v<U> = true;
+template <template<typename> concept U>
+inline constexpr bool is_concept_v<U> = true;
+
+static_assert(is_template_v<TV>);
+static_assert(is_template_v<VV>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_template_v<UV>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_template_v<TS>);
+static_assert(is_template_v<VS>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_template_v<US>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_template_v<TC>);
+static_assert(is_template_v<VC>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_template_v<UC>); // expected-error {{static assertion failed due to requirement}}
+
+
+static_assert(is_var_template_v<TV>);
+static_assert(is_var_template_v<VV>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_var_template_v<UV>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_type_template_v<TS>);
+static_assert(is_type_template_v<VS>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_type_template_v<US>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_concept_v<TC>);
+static_assert(is_concept_v<VC>); // expected-error {{static assertion failed due to requirement}}
+static_assert(is_concept_v<UC>); // expected-error {{static assertion failed due to requirement}}
+}
diff --git a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
index b0f49ebf2d2cb..bc242b1c685c7 100644
--- a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
+++ b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
@@ -1634,11 +1634,10 @@ TypeSystemClang::CreateTemplateTemplateParmDecl(const char *template_name) {
   // type that includes a template template argument. Only the name matters for
   // this purpose, so we use dummy values for the other characteristics of the
   // type.
-  return TemplateTemplateParmDecl::Create(ast, decl_ctx, SourceLocation(),
-                                          /*Depth=*/0, /*Position=*/0,
-                                          /*IsParameterPack=*/false,
-                                          &identifier_info, /*Typename=*/false,
-                                          template_param_list);
+  return TemplateTemplateParmDecl::Create(
+      ast, decl_ctx, SourceLocation(),
+      /*Depth*/ 0, /*Position*/ 0,
+      /*IsParameterPack*/ false, &identifier_info, TemplateNameKind::TNK_Type_template, template_param_list);
 }
 
 ClassTemplateSpecializationDecl *
diff --git a/llvm/cmake/modules/HandleLLVMOptions.cmake b/llvm/cmake/modules/HandleLLVMOptions.cmake
index ed13a82905b4e..83533793c7d91 100644
--- a/llvm/cmake/modules/HandleLLVMOptions.cmake
+++ b/llvm/cmake/modules/HandleLLVMOptions.cmake
@@ -754,10 +754,10 @@ if (MSVC)
       # any code that uses the LLVM_ALIGNAS macro), so this is must be disabled to
       # avoid unwanted alignment warnings.
       -wd4324 # Suppress 'structure was padded due to __declspec(align())'
-      # This is triggered for every variable that is a template type of a class even 
+      # This is triggered for every variable that is a template type of a class even
       # if there private when the class is dllexport'ed
       -wd4251 # Suppress 'needs to have dll-interface to be used by clients'
-      # We only putting dll export on classes with out of line members so this 
+      # We only putting dll export on classes with out of line members so this
       # warning gets triggered a lot for bases we haven't exported'
       -wd4275 # non dll-interface class used as base for dll-interface class
 
diff --git a/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn
index 0428322e07e3e..36a5e94912ff7 100644
--- a/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn
+++ b/llvm/utils/gn/secondary/clang/lib/AST/BUILD.gn
@@ -156,6 +156,7 @@ static_library("AST") {
     "Type.cpp",
     "TypeLoc.cpp",
     "TypePrinter.cpp",
+    "UniversalTemplateParameterName.cpp",
     "VTTBuilder.cpp",
     "VTableBuilder.cpp",
   ]