Index: include/clang/AST/ASTContext.h
===================================================================
--- include/clang/AST/ASTContext.h
+++ include/clang/AST/ASTContext.h
@@ -287,12 +287,16 @@
 
     TemplateTemplateParmDecl *getParam() const { return Parm; }
 
-    void Profile(llvm::FoldingSetNodeID &ID) { Profile(ID, Parm); }
+    void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {
+      Profile(ID, C, Parm);
+    }
 
     static void Profile(llvm::FoldingSetNodeID &ID,
+                        const ASTContext &C,
                         TemplateTemplateParmDecl *Parm);
   };
-  mutable llvm::FoldingSet<CanonicalTemplateTemplateParm>
+  mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,
+                                     const ASTContext&>
     CanonTemplateTemplateParms;
 
   TemplateTemplateParmDecl *
Index: include/clang/AST/ASTNodeTraverser.h
===================================================================
--- include/clang/AST/ASTNodeTraverser.h
+++ include/clang/AST/ASTNodeTraverser.h
@@ -490,6 +490,8 @@
   }
 
   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
+    if (const Expr *CE = D->getConstraintExpression())
+      Visit(CE);
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),
@@ -497,6 +499,8 @@
   }
 
   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
+    if (const Expr *CE = D->getConstraintExpression())
+      Visit(CE);
     if (D->hasDefaultArgument())
       Visit(D->getDefaultArgument(), SourceRange(),
             D->getDefaultArgStorage().getInheritedFrom(),
@@ -505,6 +509,8 @@
 
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());
+    if (const Expr *CE = D->getConstraintExpression())
+      Visit(CE);
     if (D->hasDefaultArgument())
       dumpTemplateArgumentLoc(
           D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
Index: include/clang/AST/DeclTemplate.h
===================================================================
--- include/clang/AST/DeclTemplate.h
+++ include/clang/AST/DeclTemplate.h
@@ -81,20 +81,24 @@
   /// pack.
   unsigned ContainsUnexpandedParameterPack : 1;
 
-  /// Whether this template parameter list has an associated requires-clause
+  /// Whether this template parameter list has a requires clause.
   unsigned HasRequiresClause : 1;
 
+  /// Whether any of the template parameters has constrained-parameter
+  /// constraint-expression.
+  unsigned HasConstrainedParameters : 1;
+
 protected:
-  TemplateParameterList(SourceLocation TemplateLoc, SourceLocation LAngleLoc,
-                        ArrayRef<NamedDecl *> Params, SourceLocation RAngleLoc,
-                        Expr *RequiresClause);
+  TemplateParameterList(const ASTContext& C, SourceLocation TemplateLoc,
+                        SourceLocation LAngleLoc, ArrayRef<NamedDecl *> Params,
+                        SourceLocation RAngleLoc, Expr *RequiresClause);
 
   size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
     return NumParams;
   }
 
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
-    return HasRequiresClause;
+    return HasRequiresClause ? 1 : 0;
   }
 
 public:
@@ -158,14 +162,22 @@
     return ContainsUnexpandedParameterPack;
   }
 
+  /// Determine whether this template parameter list contains a parameter pack.
+  bool hasParameterPack() const {
+    for (const NamedDecl *P : asArray())
+      if (P->isParameterPack())
+        return true;
+    return false;
+  }
+
   /// The constraint-expression of the associated requires-clause.
   Expr *getRequiresClause() {
-    return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
+    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
   }
 
   /// The constraint-expression of the associated requires-clause.
   const Expr *getRequiresClause() const {
-    return HasRequiresClause ? *getTrailingObjects<Expr *>() : nullptr;
+    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;
   }
 
   /// \brief All associated constraints derived from this template parameter
@@ -203,15 +215,16 @@
       >::type storage;
 
 public:
-  FixedSizeTemplateParameterListStorage(SourceLocation TemplateLoc,
+  FixedSizeTemplateParameterListStorage(const ASTContext &C,
+                                        SourceLocation TemplateLoc,
                                         SourceLocation LAngleLoc,
                                         ArrayRef<NamedDecl *> Params,
                                         SourceLocation RAngleLoc,
                                         Expr *RequiresClause)
       : FixedSizeStorageOwner(
             (assert(N == Params.size()),
-             assert(HasRequiresClause == static_cast<bool>(RequiresClause)),
-             new (static_cast<void *>(&storage)) TemplateParameterList(
+             assert(HasRequiresClause == (RequiresClause != nullptr)),
+             new (static_cast<void *>(&storage)) TemplateParameterList(C,
                  TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}
 };
 
@@ -1106,6 +1119,10 @@
       DefaultArgStorage<TemplateTypeParmDecl, TypeSourceInfo *>;
   DefArgStorage DefaultArgument;
 
+  /// \brief The constraint expression introduced by this declaration (by means
+  /// of a 'constrained-parameter'.
+  Expr *ConstraintExpression = nullptr;
+
   TemplateTypeParmDecl(DeclContext *DC, SourceLocation KeyLoc,
                        SourceLocation IdLoc, IdentifierInfo *Id,
                        bool Typename)
@@ -1182,6 +1199,30 @@
   /// Returns whether this is a parameter pack.
   bool isParameterPack() const;
 
+  /// \brief Returns the constraint expression associated with this template
+  /// parameter (if any).
+  Expr *getConstraintExpression() const {
+    return ConstraintExpression;
+  }
+
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setConstraintExpression(Expr *E) {
+    ConstraintExpression = E;
+  }
+
+  /// \brief Get the associated-constraints of this template parameter.
+  /// Currently, this will either be a vector of size 1 containing the
+  /// constrained-parameter constraint or an empty vector.
+  ///
+  /// Use this instead of getConstraintExpression for concepts APIs that
+  /// accept an ArrayRef of constraint expressions.
+  llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
+    if (ConstraintExpression)
+      return{ConstraintExpression};
+    return{};
+  }
+
   SourceRange getSourceRange() const override LLVM_READONLY;
 
   // Implement isa/cast/dyncast/etc.
@@ -1221,6 +1262,10 @@
   /// The number of types in an expanded parameter pack.
   unsigned NumExpandedTypes = 0;
 
+  /// \brief The constraint expression introduced by this declaration (by means
+  /// of a 'constrained-parameter'.
+  Expr *ConstraintExpression = nullptr;
+
   size_t numTrailingObjects(
       OverloadToken<std::pair<QualType, TypeSourceInfo *>>) const {
     return NumExpandedTypes;
@@ -1367,6 +1412,30 @@
     return TypesAndInfos[I].second;
   }
 
+  /// \brief Returns the constraint expression associated with this template
+  /// parameter (if any).
+  Expr *getConstraintExpression() const {
+    return ConstraintExpression;
+  }
+
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setConstraintExpression(Expr *E) {
+    ConstraintExpression = E;
+  }
+
+  /// \brief Get the associated-constraints of this template parameter.
+  /// Currently, this will either be a vector of size 1 containing the
+  /// constrained-parameter constraint or an empty vector.
+  ///
+  /// Use this instead of getConstraintExpression for concepts APIs that
+  /// accept an ArrayRef of constraint expressions.
+  llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
+    if (ConstraintExpression)
+      return{ConstraintExpression};
+    return{};
+  }
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }
@@ -1400,6 +1469,10 @@
   /// The number of parameters in an expanded parameter pack.
   unsigned NumExpandedParams = 0;
 
+  /// \brief The constraint expression introduced by this declaration (by means
+  /// of a 'constrained-parameter'.
+  Expr *ConstraintExpression = nullptr;
+
   TemplateTemplateParmDecl(DeclContext *DC, SourceLocation L,
                            unsigned D, unsigned P, bool ParameterPack,
                            IdentifierInfo *Id, TemplateParameterList *Params)
@@ -1527,6 +1600,30 @@
   /// Removes the default argument of this template parameter.
   void removeDefaultArgument() { DefaultArgument.clear(); }
 
+  /// \brief Returns the constraint expression associated with this template
+  /// parameter (if any).
+  Expr *getConstraintExpression() const {
+    return ConstraintExpression;
+  }
+
+  /// \brief Sets the constraint expression associated with this template
+  /// parameter (if any).
+  void setConstraintExpression(Expr *E) {
+    ConstraintExpression = E;
+  }
+
+  /// \brief Get the associated-constraints of this template parameter.
+  /// Currently, this will either be a vector of size 1 containing the
+  /// constrained-parameter constraint or an empty vector.
+  ///
+  /// Use this instead of getConstraintExpression for concepts APIs that
+  /// accept an ArrayRef of constraint expressions.
+  llvm::SmallVector<const Expr *, 1> getAssociatedConstraints() const {
+    if (ConstraintExpression)
+      return{ConstraintExpression};
+    return{};
+  }
+
   SourceRange getSourceRange() const override LLVM_READONLY {
     SourceLocation End = getLocation();
     if (hasDefaultArgument() && !defaultArgumentWasInherited())
Index: include/clang/AST/RecursiveASTVisitor.h
===================================================================
--- include/clang/AST/RecursiveASTVisitor.h
+++ include/clang/AST/RecursiveASTVisitor.h
@@ -1759,9 +1759,10 @@
   // D is the "T" in something like
   //   template <template <typename> class T> class container { };
   TRY_TO(TraverseDecl(D->getTemplatedDecl()));
-  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
+  if (Expr *CE = D->getConstraintExpression())
+    TRY_TO(TraverseStmt(CE));
+  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));
-  }
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
@@ -1773,6 +1774,8 @@
   // D is the "T" in something like "template<typename T> class vector;"
   if (D->getTypeForDecl())
     TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
+  if (Expr *CE = D->getConstraintExpression())
+    TRY_TO(TraverseStmt(CE));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
 })
@@ -2095,6 +2098,8 @@
 DEF_TRAVERSE_DECL(NonTypeTemplateParmDecl, {
   // A non-type template parameter, e.g. "S" in template<int S> class Foo ...
   TRY_TO(TraverseDeclaratorHelper(D));
+  if (Expr *CE = D->getConstraintExpression())
+    TRY_TO(TraverseStmt(CE));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseStmt(D->getDefaultArgument()));
 })
Index: include/clang/AST/TemplateBase.h
===================================================================
--- include/clang/AST/TemplateBase.h
+++ include/clang/AST/TemplateBase.h
@@ -594,6 +594,10 @@
   void addArgument(const TemplateArgumentLoc &Loc) {
     Arguments.push_back(Loc);
   }
+
+  void prependArgument(const TemplateArgumentLoc &Loc) {
+    Arguments.insert(Arguments.begin(), Loc);
+  }
 };
 
 /// Represents an explicit template argument list in C++, e.g.,
Index: include/clang/Basic/DiagnosticParseKinds.td
===================================================================
--- include/clang/Basic/DiagnosticParseKinds.td
+++ include/clang/Basic/DiagnosticParseKinds.td
@@ -730,6 +730,9 @@
 def err_explicit_instantiation_enum : Error<
   "enumerations cannot be explicitly instantiated">;
 def err_expected_template_parameter : Error<"expected template parameter">;
+def err_constrained_parameter_missing_arguments : Error<
+  "concept %0 requires more than 1 template argument; provide the remaining "
+  "arguments explicitly to use it here">;
 
 def err_missing_dependent_template_keyword : Error<
   "use 'template' keyword to treat '%0' as a dependent template name">;
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -2479,6 +2479,9 @@
 
 def err_template_different_associated_constraints : Error<
   "associated constraints differ in template redeclaration">;
+def err_template_template_parameter_not_at_least_as_constrained : Error<
+  "template template argument %0 must not be more constrained than template "
+  "template parameter %1">;
 
 // C++11 char16_t/char32_t
 def warn_cxx98_compat_unicode_type : Warning<
Index: include/clang/Parse/Parser.h
===================================================================
--- include/clang/Parse/Parser.h
+++ include/clang/Parse/Parser.h
@@ -1746,7 +1746,8 @@
                                       bool *MayBePseudoDestructor = nullptr,
                                       bool IsTypename = false,
                                       IdentifierInfo **LastII = nullptr,
-                                      bool OnlyNamespace = false);
+                                      bool OnlyNamespace = false,
+                                      bool SuppressDiagnostic = false);
 
   //===--------------------------------------------------------------------===//
   // C++0x 5.1.2: Lambda expressions
@@ -2938,7 +2939,7 @@
                           bool AllowDeductionGuide,
                           ParsedType ObjectType,
                           SourceLocation *TemplateKWLoc,
-                          UnqualifiedId &Result);
+                          UnqualifiedId &Result, bool SuppressDiag = false);
   /// Parses the mapper modifier in map, to, and from clauses.
   bool parseMapperModifier(OpenMPVarListDataTy &Data);
   /// Parses map-type-modifiers in map clause.
@@ -2974,6 +2975,17 @@
   NamedDecl *ParseTypeParameter(unsigned Depth, unsigned Position);
   NamedDecl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
   NamedDecl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
+  bool TryParseConstrainedParameter(CXXScopeSpec &SS, ConceptDecl *&CD,
+                                    NamedDecl *&FoundDecl,
+                                    SourceLocation &ConceptNameLoc,
+                                    TemplateArgumentListInfo &TALI);
+  NamedDecl *ParseConstrainedTemplateParameter(unsigned Depth,
+                                               unsigned Position,
+                                               SourceLocation ParamStartLoc,
+                                               const CXXScopeSpec &SS,
+                                               ConceptDecl *CD,
+                                               NamedDecl *FoundDecl,
+                                               TemplateArgumentListInfo TALI);
   void DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
                                  SourceLocation CorrectLoc,
                                  bool AlreadyHasEllipsis,
Index: include/clang/Sema/Sema.h
===================================================================
--- include/clang/Sema/Sema.h
+++ include/clang/Sema/Sema.h
@@ -5507,7 +5507,8 @@
                                    NamedDecl *ScopeLookupResult,
                                    bool ErrorRecoveryLookup,
                                    bool *IsCorrectedToColon = nullptr,
-                                   bool OnlyNamespace = false);
+                                   bool OnlyNamespace = false,
+                                   bool SuppressDiagnostics = false);
 
   /// The parser has parsed a nested-name-specifier 'identifier::'.
   ///
@@ -5533,6 +5534,8 @@
   ///
   /// \param OnlyNamespace If true, only considers namespaces in lookup.
   ///
+  /// \param SuppressDiagnostic If true, suppress diagnostic on error.
+  ///
   /// \returns true if an error occurred, false otherwise.
   bool ActOnCXXNestedNameSpecifier(Scope *S,
                                    NestedNameSpecInfo &IdInfo,
@@ -5540,7 +5543,8 @@
                                    CXXScopeSpec &SS,
                                    bool ErrorRecoveryLookup = false,
                                    bool *IsCorrectedToColon = nullptr,
-                                   bool OnlyNamespace = false);
+                                   bool OnlyNamespace = false,
+                                   bool SuppressDiagnostic = false);
 
   ExprResult ActOnDecltypeExpression(Expr *E);
 
@@ -5777,8 +5781,15 @@
   /// \brief Returns whether the given declaration's associated constraints are
   /// more constrained than another declaration's according to the partial
   /// ordering of constraints.
-  bool IsMoreConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                         NamedDecl *D2, ArrayRef<const Expr *> AC2);
+  /// \param NoCache If true, the subsumption cache will not be used or updated
+  /// with the result of the check. Use when the given decls may have different
+  /// associated constraints later (e.g. when D1 is a template template
+  /// parameter and AC1 are the associated constraints for the current
+  /// instantiation).
+  bool
+  IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
+                         NamedDecl *D2, ArrayRef<const Expr *> AC2,
+                         bool NoCache = false);
 
   /// \brief If D1 was not at least as constrained as D2, but would've been if
   /// a pair of atomic constraints involved had been declared in a concept and
@@ -5830,8 +5841,15 @@
   /// \brief Check that the associated constraints of a template declaration
   /// match the associated constraints of an older declaration of which it is a
   /// redeclaration
+  ///
+  /// \return whether the constraints match. If false is returned, OldMismatch
+  /// and NewMismatch (if provided) will be set to the mismatched constraint
+  /// expressions in OldAC and NewAC, respectively, or nullptr if there is no
+  /// constraint expression to point to in the respective AC.
   bool CheckRedeclarationConstraintMatch(ArrayRef<const Expr *> OldAC,
-                                         ArrayRef<const Expr *> NewAC);
+                                         ArrayRef<const Expr *> NewAC,
+                                         const Expr **OldMismatch,
+                                         const Expr **NewMismatch);
 
   /// \brief Ensure that the given template arguments satisfy the constraints
   /// associated with the given template, emitting a diagnostic if they do not.
@@ -5860,8 +5878,8 @@
   void DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLocation,
                                               StringRef Diagnostic);
 
-  void DiagnoseRedeclarationConstraintMismatch(const TemplateParameterList *Old,
-                                              const TemplateParameterList *New);
+  void DiagnoseRedeclarationConstraintMismatch(SourceLocation Old,
+                                               SourceLocation New);
 
   // ParseObjCStringLiteral - Parse Objective-C string literals.
   ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
@@ -6352,7 +6370,8 @@
                                   ParsedType ObjectType,
                                   bool EnteringContext,
                                   TemplateTy &Template,
-                                  bool &MemberOfUnknownSpecialization);
+                                  bool &MemberOfUnknownSpecialization,
+                                  NamedDecl **FoundDecl = nullptr);
 
   /// Determine whether a particular identifier might be the name in a C++1z
   /// deduction-guide declaration.
@@ -6391,7 +6410,13 @@
                                              SourceLocation Loc);
   QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
 
-  NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
+  NamedDecl *ActOnNonTypeTemplateParameter(Scope *S,
+                                      const DeclSpec &DS,
+                                      SourceLocation StartLoc,
+                                      TypeSourceInfo *TInfo,
+                                      IdentifierInfo *ParamName,
+                                      SourceLocation ParamNameLoc,
+                                      bool IsParameterPack,
                                       unsigned Depth,
                                       unsigned Position,
                                       SourceLocation EqualLoc,
@@ -6665,7 +6690,8 @@
                                    QualType InstantiatedParamType, Expr *Arg,
                                    TemplateArgument &Converted,
                                CheckTemplateArgumentKind CTAK = CTAK_Specified);
-  bool CheckTemplateTemplateArgument(TemplateParameterList *Params,
+  bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
+                                     TemplateParameterList *Params,
                                      TemplateArgumentLoc &Arg);
 
   ExprResult
@@ -7351,7 +7377,7 @@
                                     sema::TemplateDeductionInfo &Info);
 
   bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
-      TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc);
+      TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);
 
   void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
                                   bool OnlyDeduced,
Index: lib/AST/ASTContext.cpp
===================================================================
--- lib/AST/ASTContext.cpp
+++ lib/AST/ASTContext.cpp
@@ -580,8 +580,9 @@
   return FC;
 }
 
-void
+void 
 ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
+                                                   const ASTContext &C,
                                                TemplateTemplateParmDecl *Parm) {
   ID.AddInteger(Parm->getDepth());
   ID.AddInteger(Parm->getPosition());
@@ -595,6 +596,10 @@
     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
       ID.AddInteger(0);
       ID.AddBoolean(TTP->isParameterPack());
+      Expr *CE = TTP->getConstraintExpression();
+      ID.AddBoolean(CE != nullptr);
+      if (CE)
+        CE->Profile(ID, C, /*Canonical=*/true);
       continue;
     }
 
@@ -611,12 +616,34 @@
         }
       } else
         ID.AddBoolean(false);
+      Expr *CE = NTTP->getConstraintExpression();
+      ID.AddBoolean(CE != nullptr);
+      if (CE)
+        CE->Profile(ID, C, /*Canonical=*/true);
       continue;
     }
 
     auto *TTP = cast<TemplateTemplateParmDecl>(*P);
     ID.AddInteger(2);
-    Profile(ID, TTP);
+    Profile(ID, C, TTP);
+  }
+  Expr *RequiresClause = Parm->getTemplateParameters()->getRequiresClause();
+  ID.AddBoolean(RequiresClause != nullptr);
+  if (RequiresClause)
+    RequiresClause->Profile(ID, C, /*Canonical=*/true);
+  Expr *CE = Parm->getConstraintExpression();
+  ID.AddBoolean(CE != nullptr);
+  if (CE) {
+    // The constraint expression contains the template name itself as the first
+    // argument (or argument pack), so we must skip it to avoid infinite
+    // recursion.
+    auto *CSE = cast<ConceptSpecializationExpr>(CE);
+    ID.AddPointer(CSE->getNamedConcept()->getCanonicalDecl());
+
+    auto *TALI = CSE->getTemplateArgsAsWritten();
+    for (auto &Arg : TALI->arguments())
+      if (&Arg != &*TALI->arguments().begin())
+        Arg.getArgument().Profile(ID, C);
   }
 }
 
@@ -625,7 +652,7 @@
                                           TemplateTemplateParmDecl *TTP) const {
   // Check if we already have a canonical template template parameter.
   llvm::FoldingSetNodeID ID;
-  CanonicalTemplateTemplateParm::Profile(ID, TTP);
+  CanonicalTemplateTemplateParm::Profile(ID, *this, TTP);
   void *InsertPos = nullptr;
   CanonicalTemplateTemplateParm *Canonical
     = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
@@ -639,15 +666,15 @@
   for (TemplateParameterList::const_iterator P = Params->begin(),
                                           PEnd = Params->end();
        P != PEnd; ++P) {
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
-      CanonParams.push_back(
-                  TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
-                                               SourceLocation(),
-                                               SourceLocation(),
-                                               TTP->getDepth(),
-                                               TTP->getIndex(), nullptr, false,
-                                               TTP->isParameterPack()));
-    else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
+    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
+      TemplateTypeParmDecl *NewTTP = TemplateTypeParmDecl::Create(*this,
+          getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+          TTP->getDepth(), TTP->getIndex(), nullptr, false,
+          TTP->isParameterPack());
+      if (Expr *CE = TTP->getConstraintExpression())
+        NewTTP->setConstraintExpression(CE);
+      CanonParams.push_back(NewTTP);
+    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
       QualType T = getCanonicalType(NTTP->getType());
       TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
       NonTypeTemplateParmDecl *Param;
@@ -679,6 +706,8 @@
                                                 NTTP->isParameterPack(),
                                                 TInfo);
       }
+      if (Expr *CE = NTTP->getConstraintExpression())
+        Param->setConstraintExpression(CE);
       CanonParams.push_back(Param);
 
     } else
@@ -686,9 +715,9 @@
                                            cast<TemplateTemplateParmDecl>(*P)));
   }
 
-  assert(!TTP->getTemplateParameters()->getRequiresClause() &&
-         "Unexpected requires-clause on template template-parameter");
-  Expr *const CanonRequiresClause = nullptr;
+  Expr *CanonRequiresClause = nullptr;
+  if (Expr *RequiresClause = TTP->getTemplateParameters()->getRequiresClause())
+    CanonRequiresClause = RequiresClause;
 
   TemplateTemplateParmDecl *CanonTTP
     = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
@@ -702,6 +731,9 @@
                                                        SourceLocation(),
                                                        CanonRequiresClause));
 
+  if (Expr *CE = TTP->getConstraintExpression())
+    CanonTTP->setConstraintExpression(CE);
+
   // Get the new insert position for the node we care about.
   Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
   assert(!Canonical && "Shouldn't be in the map!");
@@ -772,7 +804,8 @@
                        Builtin::Context &builtins)
     : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
       DependentTemplateSpecializationTypes(this_()),
-      SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
+      SubstTemplateTemplateParmPacks(this_()),
+      CanonTemplateTemplateParms(this_()), SourceMgr(SM), LangOpts(LOpts),
       SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
       XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
                                         LangOpts.XRayNeverInstrumentFiles,
Index: lib/AST/ASTImporter.cpp
===================================================================
--- lib/AST/ASTImporter.cpp
+++ lib/AST/ASTImporter.cpp
@@ -4800,7 +4800,7 @@
   // context. This context will be fixed when the actual template declaration
   // is created.
 
-  // FIXME: Import default argument.
+  // FIXME: Import default argument  and constraint expression.
 
   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
   if (!BeginLocOrErr)
@@ -4835,7 +4835,7 @@
   else
     return Imp.takeError();
 
-  // FIXME: Import default argument.
+  // FIXME: Import default argument and constraint expression.
 
   NonTypeTemplateParmDecl *ToD = nullptr;
   (void)GetImportedOrCreateDecl(
@@ -4864,7 +4864,7 @@
   if (!TemplateParamsOrErr)
     return TemplateParamsOrErr.takeError();
 
-  // FIXME: Import default argument.
+  // FIXME: Import default argument and constraint expression.
 
   TemplateTemplateParmDecl *ToD = nullptr;
   (void)GetImportedOrCreateDecl(
Index: lib/AST/DeclTemplate.cpp
===================================================================
--- lib/AST/DeclTemplate.cpp
+++ lib/AST/DeclTemplate.cpp
@@ -43,35 +43,53 @@
 // TemplateParameterList Implementation
 //===----------------------------------------------------------------------===//
 
-TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
+
+TemplateParameterList::TemplateParameterList(const ASTContext& C,
+                                             SourceLocation TemplateLoc,
                                              SourceLocation LAngleLoc,
                                              ArrayRef<NamedDecl *> Params,
                                              SourceLocation RAngleLoc,
                                              Expr *RequiresClause)
     : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
       NumParams(Params.size()), ContainsUnexpandedParameterPack(false),
-      HasRequiresClause(static_cast<bool>(RequiresClause)) {
+      HasRequiresClause(RequiresClause != nullptr),
+      HasConstrainedParameters(false) {
   for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
     NamedDecl *P = Params[Idx];
     begin()[Idx] = P;
 
-    if (!P->isTemplateParameterPack()) {
-      if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
-        if (NTTP->getType()->containsUnexpandedParameterPack())
+    bool IsPack = P->isTemplateParameterPack();
+    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
+      if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
+        ContainsUnexpandedParameterPack = true;
+      if (Expr *CE = NTTP->getConstraintExpression()) {
+        if (CE->containsUnexpandedParameterPack())
           ContainsUnexpandedParameterPack = true;
-
-      if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
-        if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
+        HasConstrainedParameters = true;
+      }
+    } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) {
+      if (!IsPack &&
+          TTP->getTemplateParameters()->containsUnexpandedParameterPack())
+        ContainsUnexpandedParameterPack = true;
+      if (Expr *CE = TTP->getConstraintExpression()) {
+        if (CE->containsUnexpandedParameterPack())
           ContainsUnexpandedParameterPack = true;
-
-      // FIXME: If a default argument contains an unexpanded parameter pack, the
-      // template parameter list does too.
+        HasConstrainedParameters = true;
+      }
+    } else if (Expr *CE =
+                   cast<TemplateTypeParmDecl>(P)->getConstraintExpression()) {
+      if (CE->containsUnexpandedParameterPack())
+        ContainsUnexpandedParameterPack = true;
+      HasConstrainedParameters = true;
     }
+    // FIXME: If a default argument contains an unexpanded parameter pack, the
+    // template parameter list does too.
   }
-  if (RequiresClause) {
-    *getTrailingObjects<Expr *>() = RequiresClause;
+
+  if (HasRequiresClause) {
     if (RequiresClause->containsUnexpandedParameterPack())
       ContainsUnexpandedParameterPack = true;
+    *getTrailingObjects<Expr *>() = RequiresClause;
   }
 }
 
@@ -83,7 +101,7 @@
   void *Mem = C.Allocate(totalSizeToAlloc<NamedDecl *, Expr *>(
                              Params.size(), RequiresClause ? 1u : 0u),
                          alignof(TemplateParameterList));
-  return new (Mem) TemplateParameterList(TemplateLoc, LAngleLoc, Params,
+  return new (Mem) TemplateParameterList(C, TemplateLoc, LAngleLoc, Params,
                                          RAngleLoc, RequiresClause);
 }
 
@@ -140,16 +158,28 @@
 
 llvm::SmallVector<const Expr *, 3>
 TemplateParameterList::getAssociatedConstraints() const {
-  // TODO: Concepts: Collect constrained parameter constraints.
   llvm::SmallVector<const Expr *, 3> Constraints;
+  if (HasConstrainedParameters) {
+    for (const NamedDecl *Param : *this)
+      if (const TemplateTypeParmDecl *TTP
+            = dyn_cast<TemplateTypeParmDecl>(Param)) {
+        if (const Expr *Constraint = TTP->getConstraintExpression())
+          Constraints.push_back(Constraint);
+      } else if (const NonTypeTemplateParmDecl *NTTP
+                 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+        if (const Expr *Constraint = NTTP->getConstraintExpression())
+          Constraints.push_back(Constraint);
+      } else if (const Expr *Constraint = cast<TemplateTemplateParmDecl>(Param)
+                                              ->getConstraintExpression())
+        Constraints.push_back(Constraint);
+  }
   if (HasRequiresClause)
     Constraints.push_back(getRequiresClause());
   return Constraints;
 }
 
 bool TemplateParameterList::hasAssociatedConstraints() const {
-  // TODO: Concepts: Regard constrained parameter constraints.
-  return HasRequiresClause;
+  return HasRequiresClause || HasConstrainedParameters;
 }
 
 namespace clang {
Index: lib/AST/ODRHash.cpp
===================================================================
--- lib/AST/ODRHash.cpp
+++ lib/AST/ODRHash.cpp
@@ -374,6 +374,11 @@
     }
     Hash.AddBoolean(D->isParameterPack());
 
+    Expr *CE = D->getConstraintExpression();
+    Hash.AddBoolean(CE != nullptr);
+    if (CE)
+      AddStmt(CE);
+
     Inherited::VisitTemplateTypeParmDecl(D);
   }
 
@@ -387,6 +392,11 @@
     }
     Hash.AddBoolean(D->isParameterPack());
 
+    Expr *CE = D->getConstraintExpression();
+    Hash.AddBoolean(CE != nullptr);
+    if (CE)
+      AddStmt(CE);
+
     Inherited::VisitNonTypeTemplateParmDecl(D);
   }
 
@@ -400,6 +410,11 @@
     }
     Hash.AddBoolean(D->isParameterPack());
 
+    Expr *CE = D->getConstraintExpression();
+    Hash.AddBoolean(CE != nullptr);
+    if (CE)
+      AddStmt(CE);
+
     Inherited::VisitTemplateTemplateParmDecl(D);
   }
 
Index: lib/Parse/ParseExprCXX.cpp
===================================================================
--- lib/Parse/ParseExprCXX.cpp
+++ lib/Parse/ParseExprCXX.cpp
@@ -142,6 +142,9 @@
 ///
 /// \param OnlyNamespace If true, only considers namespaces in lookup.
 ///
+/// \param SuppressDiagnostic If true, suppress diagnostic on incorrect scope
+///                           specifier.
+///
 /// \returns true if there was an error parsing a scope specifier
 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
                                             ParsedType ObjectType,
@@ -149,7 +152,8 @@
                                             bool *MayBePseudoDestructor,
                                             bool IsTypename,
                                             IdentifierInfo **LastII,
-                                            bool OnlyNamespace) {
+                                            bool OnlyNamespace,
+                                            bool SuppressDiagnostic) {
   assert(getLangOpts().CPlusPlus &&
          "Call sites of this function should be guarded by checking for C++");
 
@@ -455,7 +459,7 @@
       bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
       if (Actions.ActOnCXXNestedNameSpecifier(
               getCurScope(), IdInfo, EnteringContext, SS, false,
-              CorrectionFlagPtr, OnlyNamespace)) {
+              CorrectionFlagPtr, OnlyNamespace, SuppressDiagnostic)) {
         // Identifier is not recognized as a nested name, but we can have
         // mistyped '::' instead of ':'.
         if (CorrectionFlagPtr && IsCorrectedToColon) {
@@ -476,6 +480,11 @@
     // nested-name-specifier:
     //   type-name '<'
     if (Next.is(tok::less)) {
+      if (OnlyNamespace)
+        // We can't have template-ids as part of a namespace scope specifier,
+        // the scope specifier must end here.
+        break;
+
       TemplateTy Template;
       UnqualifiedId TemplateName;
       TemplateName.setIdentifier(&II, Tok.getLocation());
@@ -2493,6 +2502,9 @@
 ///
 /// \param Result on a successful parse, contains the parsed unqualified-id.
 ///
+/// \param SuppressDiag whether to suppress the diagnostic when an unqualified
+///        id was not found at the current location.
+///
 /// \returns true if parsing fails, false otherwise.
 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
                                 bool AllowDestructorName,
@@ -2500,7 +2512,7 @@
                                 bool AllowDeductionGuide,
                                 ParsedType ObjectType,
                                 SourceLocation *TemplateKWLoc,
-                                UnqualifiedId &Result) {
+                                UnqualifiedId &Result, bool SuppressDiag) {
   if (TemplateKWLoc)
     *TemplateKWLoc = SourceLocation();
 
@@ -2730,8 +2742,9 @@
     return false;
   }
 
-  Diag(Tok, diag::err_expected_unqualified_id)
-    << getLangOpts().CPlusPlus;
+  if (!SuppressDiag)
+    Diag(Tok, diag::err_expected_unqualified_id)
+      << getLangOpts().CPlusPlus;
   return true;
 }
 
Index: lib/Parse/ParseTemplate.cpp
===================================================================
--- lib/Parse/ParseTemplate.cpp
+++ lib/Parse/ParseTemplate.cpp
@@ -12,6 +12,7 @@
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
@@ -586,16 +587,37 @@
 ///       template-parameter: [C++ temp.param]
 ///         type-parameter
 ///         parameter-declaration
+///         constrained-parameter
+///
+///       type-parameter: (See below)
+///         type-parameter-key ...[opt] identifier[opt]
+///         type-parameter-key identifier[opt] = type-id
+///         'template' '<' template-parameter-list '>' type-parameter-key
+///               ...[opt] identifier[opt]
+///         'template' '<' template-parameter-list '>' type-parameter-key
+///               identifier[opt] '=' id-expression
+///
+///       type-parameter-key:
+///         class
+///         typename
+///
+///       constrained-parameter:
+///         qualified-concept-name ... identifier[opt]
+///         qualified-concept-name identifier[opt]
+///             default-template-argument[opt]
+///
+///       qualified-concept-name:
+///         nested-name-specifier[opt] concept-name
+///         nested-name-specifier[opt] partial-concept-id
+///
+///       partial-concept-id:
+///         concept-name '<' template-argument-list[opt] '>'
+///
+///       default-template-argument:
+///         = type-id
+///         = id-expression
+///         = initializer-clause
 ///
-///       type-parameter: (see below)
-///         'class' ...[opt] identifier[opt]
-///         'class' identifier[opt] '=' type-id
-///         'typename' ...[opt] identifier[opt]
-///         'typename' identifier[opt] '=' type-id
-///         'template' '<' template-parameter-list '>'
-///               'class' ...[opt] identifier[opt]
-///         'template' '<' template-parameter-list '>' 'class' identifier[opt]
-///               = id-expression
 NamedDecl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
   if (isStartOfTemplateTypeParameter()) {
     // Is there just a typo in the input code? ('typedef' instead of 'typename')
@@ -616,12 +638,117 @@
   if (Tok.is(tok::kw_template))
     return ParseTemplateTemplateParameter(Depth, Position);
 
+  // At this point we're either facing a constrained-parameter or a typename for
+  // a non type template parameter.
+  SourceLocation ParamStartLoc = Tok.getLocation();
+  CXXScopeSpec SS;
+  ConceptDecl *CD;
+  NamedDecl *FoundDecl;
+  SourceLocation ConceptNameLoc;
+  TemplateArgumentListInfo TALI;
+  if (TryParseConstrainedParameter(SS, CD, FoundDecl, ConceptNameLoc, TALI)) {
+    if (!CD)
+      // This is definitely a constrained parameter but there's been an error
+      // parsing it.
+      return nullptr;
+    return ParseConstrainedTemplateParameter(Depth, Position, ParamStartLoc,
+                                             SS, CD, FoundDecl,
+                                             std::move(TALI));
+  }
+
   // If it's none of the above, then it must be a parameter declaration.
   // NOTE: This will pick up errors in the closure of the template parameter
   // list (e.g., template < ; Check here to implement >> style closures.
   return ParseNonTypeTemplateParameter(Depth, Position);
 }
 
+
+/// Try parsing a constrained-parameter construct at the current location. A
+/// constrained-parameter names a concept along with an optional set of template
+/// arguments, and denotes a placeholder that accepts entities that (along with
+/// the set of arguments, if any) satisfy the concept.
+/// \returns true if there is a constrained-parameter at the current location,
+/// false otherwise. If an error occured while parsing the
+/// constrained-parameter, the returned CD will be nullptr.
+bool Parser::TryParseConstrainedParameter(CXXScopeSpec &SS, ConceptDecl *&CD,
+                                          NamedDecl *&FoundDecl,
+                                          SourceLocation &ConceptNameLoc,
+                                          TemplateArgumentListInfo &TALI) {
+  TentativeParsingAction TPA(*this);
+
+  if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
+                                     /*EnteringContext=*/false,
+                                     /*MayBePseudoDestructor=*/nullptr,
+                                     /*IsTypename=*/false,
+                                     /*LastII=*/nullptr,
+                                     /*OnlyNamespace=*/true,
+                                     /*SuppressDiagnostics=*/true)) {
+    TPA.Revert();
+    return false;
+  }
+
+  if (!Tok.is(tok::identifier)) {
+    TPA.Revert();
+    return false;
+  }
+
+  UnqualifiedId PossibleConceptName;
+  PossibleConceptName.setIdentifier(Tok.getIdentifierInfo(),
+                                    Tok.getLocation());
+  ConceptNameLoc = ConsumeToken();
+
+  TemplateTy PossibleConcept;
+  bool MemberOfUnknownSpecialization = false;
+  auto TNK = Actions.isTemplateName(getCurScope(), SS,
+                                    /*hasTemplateKeyword=*/false,
+                                    PossibleConceptName,
+                                    /*ObjectType=*/ParsedType(),
+                                    /*EnteringContext=*/false,
+                                    PossibleConcept,
+                                    MemberOfUnknownSpecialization, &FoundDecl);
+  assert(!MemberOfUnknownSpecialization
+         && "Member when we only allowed namespace scope qualifiers??");
+  if (!PossibleConcept || TNK != TNK_Concept_template) {
+    TPA.Revert();
+    return false;
+  }
+
+  TPA.Commit();
+
+  // At this point we're sure we're dealing with a constrained parameter. It
+  // may or may not have a template parameter list following the concept name.
+  if (Tok.is(tok::less)) {
+    if (AnnotateTemplateIdToken(PossibleConcept, TNK, SS,
+                                /*TemplateKWLoc=*/SourceLocation(),
+                                PossibleConceptName,
+                                /*AllowTypeAnnotation=*/false)) {
+      CD = nullptr;
+      return true;
+    }
+    auto *TemplateId = (TemplateIdAnnotation*)Tok.getAnnotationValue();
+    TALI.setLAngleLoc(TemplateId->LAngleLoc);
+    TALI.setRAngleLoc(TemplateId->RAngleLoc);
+    // Translate the parser's template argument list into our AST format.
+    Actions.translateTemplateArguments(
+      MutableArrayRef<ParsedTemplateArgument>(
+        TemplateId->getTemplateArgs(),
+        TemplateId->NumArgs), TALI);
+    ConsumeAnnotationToken();
+  }
+
+  CD = cast<ConceptDecl>(PossibleConcept.get().getAsTemplateDecl());
+
+  // If the user did not use a partial concept id and the concept does not
+  // accept a single argument or parameter pack, fail now with a nicer error
+  // message
+  if (TALI.size() == 0
+      && CD->getTemplateParameters()->getMinRequiredArguments() > 1) {
+    Diag(diag::err_constrained_parameter_missing_arguments) << CD;
+    CD = nullptr;
+  }
+  return true;
+}
+
 /// ParseTypeParameter - Parse a template type parameter (C++ [temp.param]).
 /// Other kinds of template parameters are parsed in
 /// ParseTemplateTemplateParameter and ParseNonTypeTemplateParameter.
@@ -841,11 +968,215 @@
   }
 
   // Create the parameter.
-  return Actions.ActOnNonTypeTemplateParameter(getCurScope(), ParamDecl,
-                                               Depth, Position, EqualLoc,
+  return Actions.ActOnNonTypeTemplateParameter(getCurScope(),
+                                               ParamDecl.getDeclSpec(),
+                                               ParamDecl.getBeginLoc(),
+                                               Actions.GetTypeForDeclarator(
+                                                      ParamDecl, getCurScope()),
+                                               ParamDecl.getIdentifier(),
+                                               ParamDecl.getIdentifierLoc(),
+                                               ParamDecl.hasEllipsis(),
+                                               Depth, Position, EqualLoc, 
                                                DefaultArg.get());
 }
 
+NamedDecl *
+Parser::ParseConstrainedTemplateParameter(unsigned Depth, unsigned Position,
+                                          SourceLocation ParamStartLoc,
+                                          const CXXScopeSpec &SS,
+                                          ConceptDecl *CD, NamedDecl *FoundDecl,
+                                          TemplateArgumentListInfo TALI) {
+  // Grab the ellipsis (if given).
+  SourceLocation EllipsisLoc;
+  TryConsumeToken(tok::ellipsis, EllipsisLoc);
+
+  // Grab the template parameter name (if given)
+  SourceLocation NameLoc;
+  IdentifierInfo *ParamName = nullptr;
+  if (Tok.is(tok::identifier)) {
+    ParamName = Tok.getIdentifierInfo();
+    NameLoc = ConsumeToken();
+  } else if (Tok.isOneOf(tok::equal, tok::comma, tok::greater,
+                         tok::greatergreater)) {
+    // Unnamed template parameter. Don't have to do anything here, just
+    // don't consume this token.
+  } else {
+    Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
+    return nullptr;
+  }
+
+  // Recover from misplaced ellipsis.
+  bool AlreadyHasEllipsis = EllipsisLoc.isValid();
+  if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
+    DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis,
+                              true);
+
+  // Grab a default argument (if available).
+  // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
+  // we introduce the type parameter into the local scope.
+  SourceLocation EqualLoc;
+
+  NamedDecl *DeclaredParm = nullptr;
+  NamedDecl *ConceptPrototypeParameter = *CD->getTemplateParameters()->begin();
+  if (TemplateTypeParmDecl *TypeP = dyn_cast<TemplateTypeParmDecl>(
+                                      ConceptPrototypeParameter)) {
+    ParsedType DefaultArg;
+    if (TryConsumeToken(tok::equal, EqualLoc))
+      DefaultArg = ParseTypeName(/*SourceRange=*/nullptr,
+                                 DeclaratorContext::TemplateTypeArgContext)
+                     .get();
+    DeclaredParm = cast_or_null<NamedDecl>(
+      Actions.ActOnTypeParameter(getCurScope(),
+                                 TypeP->wasDeclaredWithTypename(),
+                                 EllipsisLoc, ParamStartLoc, ParamName,
+                                 NameLoc, Depth, Position, EqualLoc,
+                                 DefaultArg));
+    if (!DeclaredParm)
+      return nullptr;
+
+    QualType Q(cast<TemplateTypeParmDecl>(DeclaredParm)->getTypeForDecl(),
+               0);
+    if (!EllipsisLoc.isInvalid()
+        && CD->getTemplateParameters()->hasParameterPack())
+      // C++ [temp.param]p11.1
+      //   If P declares a template parameter pack and C is a variadic concept,
+      //   then A is the pack expansion P... . Otherwise, A is the
+      //   id-expression P.
+      Q = Actions.Context.getPackExpansionType(Q, /*NumExpansions=*/None);
+    TALI.prependArgument(
+      TemplateArgumentLoc(TemplateArgument(Q),
+                          TemplateArgumentLocInfo(
+                            Actions.Context.getTrivialTypeSourceInfo(Q))));
+  } else if (TemplateTemplateParmDecl *TemplateP =
+               dyn_cast<TemplateTemplateParmDecl>(ConceptPrototypeParameter)) {
+    ParsedTemplateArgument DefaultArg;
+    if (TryConsumeToken(tok::equal, EqualLoc)) {
+      DefaultArg = ParseTemplateTemplateArgument();
+      if (DefaultArg.isInvalid()) {
+        Diag(Tok.getLocation(),
+             diag::err_default_template_template_parameter_not_template);
+        SkipUntil(tok::comma, tok::greater, tok::greatergreater,
+                  StopAtSemi | StopBeforeMatch);
+      }
+    }
+
+
+    DeclaredParm = cast_or_null<NamedDecl>(
+      Actions.ActOnTemplateTemplateParameter(getCurScope(),
+                                             ParamStartLoc,
+                                             TemplateP->getTemplateParameters(),
+                                             EllipsisLoc, ParamName,
+                                             NameLoc, Depth, Position,
+                                             EqualLoc, DefaultArg));
+    if (!DeclaredParm)
+      return nullptr;
+    TemplateName TemplName(cast_or_null<TemplateDecl>(DeclaredParm));
+
+    // C++ [temp.param]p11.1
+    //   If P declares a template parameter pack and C is a variadic concept,
+    //   then A is the pack expansion P... . Otherwise, A is the
+    //   id-expression P.
+    bool ShouldExpand = !EllipsisLoc.isInvalid()
+        && CD->getTemplateParameters()->hasParameterPack();
+
+    NestedNameSpecifierLocBuilder Builder;
+    TemplateArgumentLocInfo LocInf(Builder.getWithLocInContext(Actions.Context),
+                                   NameLoc, EllipsisLoc);
+    TemplateArgumentLoc TAL(ShouldExpand
+                            ? TemplateArgument(TemplName, Optional<unsigned>())
+                            : TemplateArgument(TemplName), LocInf);
+    TALI.prependArgument(TAL);
+  } else if (NonTypeTemplateParmDecl *NonTypeP =
+               dyn_cast<NonTypeTemplateParmDecl>(ConceptPrototypeParameter)) {
+    ExprResult DefaultArg;
+    if (TryConsumeToken(tok::equal, EqualLoc)) {
+      // C++ [temp.param]p15:
+      //   When parsing a default template-argument for a non-type
+      //   template-parameter, the first non-nested > is taken as the
+      //   end of the template-parameter-list rather than a greater-than
+      //   operator.
+      GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
+      EnterExpressionEvaluationContext ConstantEvaluated(
+          Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+
+      DefaultArg = Actions.CorrectDelayedTyposInExpr(
+                     ParseAssignmentExpression());
+      if (DefaultArg.isInvalid())
+        SkipUntil(tok::comma, tok::greater, StopAtSemi | StopBeforeMatch);
+    }
+
+    DeclaredParm = cast_or_null<NamedDecl>(
+      Actions.ActOnNonTypeTemplateParameter(getCurScope(),
+                                            DeclSpec(getAttrFactory()),
+                                            ParamStartLoc,
+                                            NonTypeP->getTypeSourceInfo(),
+                                            ParamName, NameLoc,
+                                            EllipsisLoc.isValid(),
+                                            Depth, Position, EqualLoc,
+                                            DefaultArg.isInvalid() ? nullptr :
+                                                             DefaultArg.get()));
+    if (!DeclaredParm)
+      return nullptr;
+
+    ValueDecl *VD = cast<ValueDecl>(DeclaredParm);
+    Expr *DerivedArgument =
+      new (Actions.Context) DeclRefExpr(Actions.Context, VD,
+                                   /*RefersToEnclosingVariableOrCapture=*/false,
+                                        VD->getType(), VK_LValue, NameLoc,
+                                        DeclarationNameLoc(VD->getDeclName()));
+    // C++ [temp.param]p11.1
+    //   If P declares a template parameter pack and C is a variadic concept,
+    //   then A is the pack expansion P... . Otherwise, A is the
+    //   id-expression P.
+    if (EllipsisLoc.isValid()
+        && CD->getTemplateParameters()->hasParameterPack())
+      DerivedArgument =
+        new (Actions.Context) PackExpansionExpr(Actions.Context.DependentTy,
+                                                DerivedArgument, EllipsisLoc,
+                                                /*NumExpansions=*/None);
+    TemplateArgument DeclaredParmA(DerivedArgument);
+    TALI.prependArgument(
+      TemplateArgumentLoc(DeclaredParmA,
+                          TemplateArgumentLocInfo(DerivedArgument)));
+  } else
+    llvm_unreachable("Unrecognized concept prototype parameter type.");
+
+  // We now have an actual template parameter declared - form the constraint
+  // expression and attach it to the declared parameter.
+
+  ExprResult Result = Actions.CheckConceptTemplateId(SS,
+      /*TemplateKWLoc=*/SourceLocation(), ParamStartLoc, FoundDecl, CD, &TALI);
+  if (Result.isInvalid() || !Result.isUsable())
+    // Just ignore the constraint and attempt to continue.
+    return DeclaredParm;
+
+  Expr *IntroducedConstraint = Result.get();
+  if (EllipsisLoc.isValid() && !CD->getTemplateParameters()->hasParameterPack())
+    // We have the following case:
+    //
+    // template<typename T> concept C1 = true;
+    // template<C1... T> struct s1;
+    //
+    // The constraint: (C1<T> && ...)
+    IntroducedConstraint =
+      Actions.ActOnCXXFoldExpr(/*LParenLoc=*/SourceLocation(),
+                               IntroducedConstraint, tok::ampamp,
+                               EllipsisLoc, /*RHS=*/nullptr,
+                               /*RParenLoc=*/SourceLocation()).get();
+
+  if (TemplateTypeParmDecl *TypeP =
+        dyn_cast<TemplateTypeParmDecl>(DeclaredParm))
+    TypeP->setConstraintExpression(IntroducedConstraint);
+  else if (TemplateTemplateParmDecl *TemplateP =
+               dyn_cast<TemplateTemplateParmDecl>(DeclaredParm))
+    TemplateP->setConstraintExpression(IntroducedConstraint);
+  else
+    cast<NonTypeTemplateParmDecl>(DeclaredParm)
+      ->setConstraintExpression(IntroducedConstraint);
+
+  return DeclaredParm;
+}
+
 void Parser::DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
                                        SourceLocation CorrectLoc,
                                        bool AlreadyHasEllipsis,
Index: lib/Sema/SemaCXXScopeSpec.cpp
===================================================================
--- lib/Sema/SemaCXXScopeSpec.cpp
+++ lib/Sema/SemaCXXScopeSpec.cpp
@@ -468,6 +468,7 @@
 ///       'true' if the identifier is treated as if it was followed by ':',
 ///        not '::'.
 /// \param OnlyNamespace If true, only considers namespaces in lookup.
+/// \param SuppressDiagnostics If true, will not emit diagnostics on an error.
 ///
 /// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
 /// that it contains an extra parameter \p ScopeLookupResult, which provides
@@ -485,7 +486,8 @@
                                        NamedDecl *ScopeLookupResult,
                                        bool ErrorRecoveryLookup,
                                        bool *IsCorrectedToColon,
-                                       bool OnlyNamespace) {
+                                       bool OnlyNamespace,
+                                       bool SuppressDiagnostics) {
   if (IdInfo.Identifier->isEditorPlaceholder())
     return true;
   LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
@@ -580,7 +582,7 @@
     return false;
   }
 
-  if (Found.empty() && !ErrorRecoveryLookup) {
+  if (Found.empty() && !ErrorRecoveryLookup && !SuppressDiagnostics) {
     // If identifier is not found as class-name-or-namespace-name, but is found
     // as other entity, don't look for typos.
     LookupResult R(*this, Found.getLookupNameInfo(), LookupOrdinaryName);
@@ -614,7 +616,8 @@
     }
   }
 
-  if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
+  if (Found.empty() && !ErrorRecoveryLookup && !SuppressDiagnostics
+      && !getLangOpts().MSVCCompat) {
     // We haven't found anything, and we're not recovering from a
     // different kind of error, so look for typos.
     DeclarationName Name = Found.getLookupName();
@@ -684,7 +687,7 @@
            !Context.hasSameType(
                             Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
                                Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
-        if (ErrorRecoveryLookup)
+        if (ErrorRecoveryLookup || SuppressDiagnostics)
           return true;
 
          Diag(IdInfo.IdentifierLoc,
@@ -766,7 +769,7 @@
 
   // Otherwise, we have an error case.  If we don't want diagnostics, just
   // return an error now.
-  if (ErrorRecoveryLookup)
+  if (ErrorRecoveryLookup || SuppressDiagnostics)
     return true;
 
   // If we didn't find anything during our lookup, try again with
@@ -834,13 +837,15 @@
                                        bool EnteringContext, CXXScopeSpec &SS,
                                        bool ErrorRecoveryLookup,
                                        bool *IsCorrectedToColon,
-                                       bool OnlyNamespace) {
+                                       bool OnlyNamespace,
+                                       bool SuppressDiagnostic) {
   if (SS.isInvalid())
     return true;
 
   return BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
                                      /*ScopeLookupResult=*/nullptr, false,
-                                     IsCorrectedToColon, OnlyNamespace);
+                                     IsCorrectedToColon, OnlyNamespace,
+                                     SuppressDiagnostic);
 }
 
 bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
Index: lib/Sema/SemaConcept.cpp
===================================================================
--- lib/Sema/SemaConcept.cpp
+++ lib/Sema/SemaConcept.cpp
@@ -50,27 +50,53 @@
 }
 
 bool Sema::CheckRedeclarationConstraintMatch(ArrayRef<const Expr *> OldAC,
-                                             ArrayRef<const Expr *> NewAC) {
+                                             ArrayRef<const Expr *> NewAC,
+                                             const Expr **OldMismatch,
+                                             const Expr **NewMismatch) {
+  assert((!OldMismatch == !NewMismatch) &&
+         "Either both or neither of OldMismatch, NewMismatch must be provided");
   if (NewAC.empty() && OldAC.empty())
     return true; // Nothing to check; no mismatch.
-  if (NewAC.size() != OldAC.size())
+  if ((NewAC.size() != OldAC.size()) && !OldMismatch)
     return false;
-  llvm::FoldingSetNodeID OldACInfo, NewACInfo;
-  for (const Expr *E : NewAC)
-    E->Profile(NewACInfo, Context, /*Canonical=*/true);
-  for (const Expr *E : OldAC)
-    E->Profile(OldACInfo, Context, /*Canonical=*/true);
-  return NewACInfo == OldACInfo;
+  unsigned I = 0, C = std::min(NewAC.size(), OldAC.size());
+  for (; I < C; ++I) {
+    llvm::FoldingSetNodeID OldACInfo, NewACInfo;
+    OldAC[I]->Profile(OldACInfo, Context, /*Canonical=*/true);
+    NewAC[I]->Profile(NewACInfo, Context, /*Canonical=*/true);
+    if (OldACInfo != NewACInfo) {
+      if (OldMismatch) {
+        *OldMismatch = OldAC[I];
+        *NewMismatch = NewAC[I];
+      }
+      return false;
+    }
+  }
+  if (I < OldAC.size()) {
+    // OldAC is longer than NewAC - mismatch
+    if (OldMismatch) {
+      *OldMismatch = OldAC[I];
+      *NewMismatch = nullptr;
+    }
+    return false;
+  } else if (I < NewAC.size()) {
+    // NewAC is longer than OldAC - mismatch
+    if (OldMismatch) {
+      *OldMismatch = nullptr;
+      *NewMismatch = NewAC[I];
+    }
+    return false;
+  }
+  // They were the same size - a match!
+  return true;
 }
 
 void
-Sema::DiagnoseRedeclarationConstraintMismatch(const TemplateParameterList *Old,
-                                              const TemplateParameterList *New){
-  Diag(New->getTemplateLoc(),
-       diag::err_template_different_associated_constraints);
+Sema::DiagnoseRedeclarationConstraintMismatch(SourceLocation Old,
+                                              SourceLocation New){
+  Diag(New, diag::err_template_different_associated_constraints);
 
-  Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
-        << /*declaration*/0;
+  Diag(Old, diag::note_template_prev_declaration) << /*declaration*/0;
 }
 
 template <typename AtomicEvaluator>
@@ -852,8 +878,9 @@
   return false;
 }
 
-bool Sema::IsMoreConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                             NamedDecl *D2, ArrayRef<const Expr *> AC2) {
+bool Sema::IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
+                                  NamedDecl *D2, ArrayRef<const Expr *> AC2,
+                                  bool NoCache) {
   if (AC1.empty())
     return AC2.empty();
   if (AC2.empty())
@@ -861,9 +888,11 @@
     return true;
 
   std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
-  auto CacheEntry = SubsumptionCache.find(Key);
-  if (CacheEntry != SubsumptionCache.end())
-    return CacheEntry->second;
+  if (!NoCache) {
+    auto CacheEntry = SubsumptionCache.find(Key);
+    if (CacheEntry != SubsumptionCache.end())
+      return CacheEntry->second;
+  }
 
   bool Subsumes;
   if (subsumes(*this, AC1, AC2, Subsumes,
@@ -872,7 +901,8 @@
         }))
     // Program is ill-formed at this point.
     return false;
-  SubsumptionCache.try_emplace(Key, Subsumes);
+  if (!NoCache)
+    SubsumptionCache.try_emplace(Key, Subsumes);
   return Subsumes;
 }
 
Index: lib/Sema/SemaOverload.cpp
===================================================================
--- lib/Sema/SemaOverload.cpp
+++ lib/Sema/SemaOverload.cpp
@@ -9370,10 +9370,14 @@
       Expr *RC1 = Cand1.Function->getTrailingRequiresClause();
       Expr *RC2 = Cand2.Function->getTrailingRequiresClause();
       if (RC1 && RC2) {
-        bool AtLeastAsConstrained1 = S.IsMoreConstrained(Cand1.Function, RC1,
-                                                         Cand2.Function, RC2);
-        bool AtLeastAsConstrained2 = S.IsMoreConstrained(Cand2.Function, RC2,
-                                                         Cand1.Function, RC1);
+        bool AtLeastAsConstrained1 = S.IsAtLeastAsConstrained(Cand1.Function,
+                                                              RC1,
+                                                              Cand2.Function,
+                                                              RC2);
+        bool AtLeastAsConstrained2 = S.IsAtLeastAsConstrained(Cand2.Function,
+                                                              RC2,
+                                                              Cand1.Function,
+                                                              RC1);
         if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
           return AtLeastAsConstrained1;
       } else if (RC1 || RC2)
@@ -11658,17 +11662,16 @@
     // We have more than one result - see if it is more constrained than the
     // previous one.
     if (Result) {
-      bool ResultMoreConstrained = IsMoreConstrained(Result,
-                                           Result->getAssociatedConstraints(),
-                                           FD, FD->getAssociatedConstraints());
-      bool FDMoreConstrained = IsMoreConstrained(FD,
-                                           FD->getAssociatedConstraints(),
-                                           Result,
-                                           Result->getAssociatedConstraints());
-      if (ResultMoreConstrained == FDMoreConstrained) {
+      bool ResultAtLeastAsConstrained = IsAtLeastAsConstrained(Result,
+          Result->getAssociatedConstraints(), FD,
+          FD->getAssociatedConstraints());
+      bool FDAtLeastAsConstrained = IsAtLeastAsConstrained(FD,
+          FD->getAssociatedConstraints(), Result,
+          Result->getAssociatedConstraints());
+      if (ResultAtLeastAsConstrained == FDAtLeastAsConstrained) {
         IsResultAmbiguous = true;
         continue;
-      } else if (ResultMoreConstrained)
+      } else if (ResultAtLeastAsConstrained)
         continue;
       // FD is more constrained replace Result with it.
     }
Index: lib/Sema/SemaTemplate.cpp
===================================================================
--- lib/Sema/SemaTemplate.cpp
+++ lib/Sema/SemaTemplate.cpp
@@ -125,7 +125,8 @@
                                       ParsedType ObjectTypePtr,
                                       bool EnteringContext,
                                       TemplateTy &TemplateResult,
-                                      bool &MemberOfUnknownSpecialization) {
+                                      bool &MemberOfUnknownSpecialization,
+                                      NamedDecl **FoundDecl) {
   assert(getLangOpts().CPlusPlus && "No template names in C!");
 
   DeclarationName TName;
@@ -203,6 +204,8 @@
     // We'll do this lookup again later.
     R.suppressDiagnostics();
   } else {
+    if (FoundDecl)
+      *FoundDecl = R.getFoundDecl();
     if (!D) {
       D = getAsTemplateNameDecl(*R.begin());
       assert(D && "unambiguous result is not a template name");
@@ -1039,15 +1042,20 @@
   return QualType();
 }
 
-NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
+NamedDecl *Sema::ActOnNonTypeTemplateParameter(Scope *S,
+                                          const DeclSpec &DS,
+                                          SourceLocation StartLoc,
+                                          TypeSourceInfo *TInfo,
+                                          IdentifierInfo *ParamName,
+                                          SourceLocation ParamNameLoc,
+                                          bool IsParameterPack,
                                           unsigned Depth,
                                           unsigned Position,
                                           SourceLocation EqualLoc,
                                           Expr *Default) {
-  TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
 
   // Check that we have valid decl-specifiers specified.
-  auto CheckValidDeclSpecifiers = [this, &D] {
+  auto CheckValidDeclSpecifiers = [this, &DS] {
     // C++ [temp.param]
     // p1 
     //   template-parameter:
@@ -1059,7 +1067,6 @@
     // [dcl.typedef]p1:
     //   The typedef specifier [...] shall not be used in the decl-specifier-seq
     //   of a parameter-declaration
-    const DeclSpec &DS = D.getDeclSpec();
     auto EmitDiag = [this](SourceLocation Loc) {
       Diag(Loc, diag::err_invalid_decl_specifier_in_nontype_parm)
           << FixItHint::CreateRemoval(Loc);
@@ -1101,7 +1108,7 @@
   CheckValidDeclSpecifiers();
 
   if (TInfo->getType()->isUndeducedType()) {
-    Diag(D.getIdentifierLoc(),
+    Diag(ParamNameLoc,
          diag::warn_cxx14_compat_template_nontype_parm_auto_type)
       << QualType(TInfo->getType()->getContainedAutoType(), 0);
   }
@@ -1110,26 +1117,25 @@
          "Non-type template parameter not in template parameter scope!");
   bool Invalid = false;
 
-  QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
+  QualType T = CheckNonTypeTemplateParameterType(TInfo, ParamNameLoc);
   if (T.isNull()) {
     T = Context.IntTy; // Recover with an 'int' type.
     Invalid = true;
   }
 
-  IdentifierInfo *ParamName = D.getIdentifier();
-  bool IsParameterPack = D.hasEllipsis();
-  NonTypeTemplateParmDecl *Param = NonTypeTemplateParmDecl::Create(
-      Context, Context.getTranslationUnitDecl(), D.getBeginLoc(),
-      D.getIdentifierLoc(), Depth, Position, ParamName, T, IsParameterPack,
-      TInfo);
+  NonTypeTemplateParmDecl *Param
+    = NonTypeTemplateParmDecl::Create(Context, Context.getTranslationUnitDecl(),
+                                      StartLoc,
+                                      ParamNameLoc,
+                                      Depth, Position, ParamName, T,
+                                      IsParameterPack, TInfo);
   Param->setAccess(AS_public);
 
   if (Invalid)
     Param->setInvalidDecl();
 
   if (ParamName) {
-    maybeDiagnoseTemplateParameterShadow(*this, S, D.getIdentifierLoc(),
-                                         ParamName);
+    maybeDiagnoseTemplateParameterShadow(*this, S, ParamNameLoc, ParamName);
 
     // Add the template parameter into the current scope.
     S->AddDecl(Param);
@@ -1787,6 +1793,11 @@
           /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
           TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
           TTP->isParameterPack());
+      if (Expr *CE = TTP->getConstraintExpression()) {
+        ExprResult InstantiatedConstraintExpr = SemaRef.SubstExpr(CE, Args);
+        if (InstantiatedConstraintExpr.isUsable())
+          NewTTP->setConstraintExpression(InstantiatedConstraintExpr.get());
+      }
       if (TTP->hasDefaultArgument()) {
         TypeSourceInfo *InstantiatedDefaultArg =
             SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
@@ -2156,14 +2167,17 @@
   if (OldParams)
     OldParam = OldParams->begin();
 
+  const Expr *OldMismatch, *NewMismatch;
   if (OldParams &&
       !CheckRedeclarationConstraintMatch(OldParams->getAssociatedConstraints(),
-                                       NewParams->getAssociatedConstraints())) {
-    Diag(NewParams->getTemplateLoc(),
-         diag::err_template_different_associated_constraints);
-    Diag(OldParams->getTemplateLoc(),  diag::note_template_prev_declaration)
-        << /*declaration*/0;
-
+                                         NewParams->getAssociatedConstraints(),
+                                         &OldMismatch, &NewMismatch)){
+    DiagnoseRedeclarationConstraintMismatch(OldMismatch ?
+                                            OldMismatch->getBeginLoc() :
+                                            OldParams->getTemplateLoc(),
+                                            NewMismatch ?
+                                            NewMismatch->getBeginLoc() :
+                                            NewParams->getTemplateLoc());
     Invalid = true;
   }
 
@@ -4998,7 +5012,7 @@
 
   case TemplateArgument::Template:
   case TemplateArgument::TemplateExpansion:
-    if (CheckTemplateTemplateArgument(Params, Arg))
+    if (CheckTemplateTemplateArgument(TempParm, Params, Arg))
       return true;
 
     Converted.push_back(Arg.getArgument());
@@ -6747,7 +6761,8 @@
 ///
 /// This routine implements the semantics of C++ [temp.arg.template].
 /// It returns true if an error occurred, and false otherwise.
-bool Sema::CheckTemplateTemplateArgument(TemplateParameterList *Params,
+bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
+                                         TemplateParameterList *Params,
                                          TemplateArgumentLoc &Arg) {
   TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
   TemplateDecl *Template = Name.getAsTemplateDecl();
@@ -6786,19 +6801,43 @@
   // C++1z [temp.arg.template]p3: (DR 150)
   //   A template-argument matches a template template-parameter P when P
   //   is at least as specialized as the template-argument A.
-  if (getLangOpts().RelaxedTemplateTemplateArgs) {
+  if (getLangOpts().RelaxedTemplateTemplateArgs || getLangOpts().ConceptsTS) {
     // Quick check for the common case:
     //   If P contains a parameter pack, then A [...] matches P if each of A's
     //   template parameters matches the corresponding template parameter in
     //   the template-parameter-list of P.
     if (TemplateParameterListsAreEqual(
             Template->getTemplateParameters(), Params, false,
-            TPL_TemplateTemplateArgumentMatch, Arg.getLocation()))
+            TPL_TemplateTemplateArgumentMatch, Arg.getLocation()) &&
+        // If the argument has no associated constraints, then the parameter is
+        // definitely at least as specialized as the argument.
+        // Otherwise - we need a more thorough check.
+        !Template->hasAssociatedConstraints())
       return false;
 
     if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
-                                                          Arg.getLocation()))
+                                                          Arg.getLocation())) {
+      // C++2a[temp.func.order]p2
+      //   [...] If both deductions succeed, the partial ordering selects the
+      //   more constrained template as described by the rules in
+      //   [temp.constr.order].
+      if (!IsAtLeastAsConstrained(Param, Params->getAssociatedConstraints(),
+                                  Template,
+                                  Template->getAssociatedConstraints(),
+                                  /*NoCache=*/true)) {
+        Diag(Arg.getLocation(),
+             diag::err_template_template_parameter_not_at_least_as_constrained)
+            << Template << Param << Arg.getSourceRange();
+        Diag(Param->getLocation(), diag::note_entity_declared_at) << Param;
+        Diag(Template->getLocation(), diag::note_entity_declared_at)
+            << Template;
+        MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param,
+            Params->getAssociatedConstraints(), Template,
+            Template->getAssociatedConstraints());
+        return true;
+      }
       return false;
+    }
     // FIXME: Produce better diagnostics for deduction failures.
   }
 
@@ -6997,7 +7036,6 @@
                                        bool Complain,
                                      Sema::TemplateParameterListEqualKind Kind,
                                        SourceLocation TemplateArgLoc) {
-  // TODO: Concepts: Check constrained-parameter constraints here.
   // Check the actual kind (type, non-type, template).
   if (Old->getKind() != New->getKind()) {
     if (Complain) {
@@ -7042,55 +7080,75 @@
     return false;
   }
 
+  llvm::SmallVector<const Expr *, 1> OldAC, NewAC;
+
   // For non-type template parameters, check the type of the parameter.
   if (NonTypeTemplateParmDecl *OldNTTP
                                     = dyn_cast<NonTypeTemplateParmDecl>(Old)) {
     NonTypeTemplateParmDecl *NewNTTP = cast<NonTypeTemplateParmDecl>(New);
+    OldAC = OldNTTP->getAssociatedConstraints();
+    NewAC = NewNTTP->getAssociatedConstraints();
 
     // 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()))
-      return true;
-
-    if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
-      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 (Kind != Sema::TPL_TemplateTemplateArgumentMatch ||
+        (!OldNTTP->getType()->isDependentType() &&
+         !NewNTTP->getType()->isDependentType()))
+      if (!S.Context.hasSameType(OldNTTP->getType(), NewNTTP->getType())) {
+        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 true;
+        return false;
+      }
   }
-
   // For template template parameters, check the template parameter types.
   // The template parameter lists of template template
   // parameters must agree.
-  if (TemplateTemplateParmDecl *OldTTP
+  else if (TemplateTemplateParmDecl *OldTTP
                                     = dyn_cast<TemplateTemplateParmDecl>(Old)) {
     TemplateTemplateParmDecl *NewTTP = cast<TemplateTemplateParmDecl>(New);
-    return S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
-                                            OldTTP->getTemplateParameters(),
-                                            Complain,
+    OldAC = OldTTP->getAssociatedConstraints();
+    NewAC = NewTTP->getAssociatedConstraints();
+    if (!S.TemplateParameterListsAreEqual(NewTTP->getTemplateParameters(),
+                                          OldTTP->getTemplateParameters(),
+                                          Complain,
                                         (Kind == Sema::TPL_TemplateMatch
                                            ? Sema::TPL_TemplateTemplateParmMatch
                                            : Kind),
-                                            TemplateArgLoc);
+                                          TemplateArgLoc))
+      return false;
+  } else {
+    OldAC = cast<TemplateTypeParmDecl>(Old)->getAssociatedConstraints();
+    NewAC = cast<TemplateTypeParmDecl>(New)->getAssociatedConstraints();
+  }
+
+  const Expr *OldMismatch, *NewMismatch;
+  if (Kind != Sema::TPL_TemplateTemplateArgumentMatch &&
+      !S.CheckRedeclarationConstraintMatch(OldAC, NewAC,
+                                           Complain ? &OldMismatch : nullptr,
+                                           Complain ? &NewMismatch : nullptr)) {
+    if (Complain)
+      S.DiagnoseRedeclarationConstraintMismatch(OldMismatch ?
+                                                OldMismatch->getBeginLoc() :
+                                                Old->getBeginLoc(),
+                                                NewMismatch ?
+                                                NewMismatch->getBeginLoc() :
+                                                New->getBeginLoc());
+    return false;
   }
 
   return true;
@@ -7207,10 +7265,19 @@
     return false;
   }
 
-  if (!CheckRedeclarationConstraintMatch(Old->getAssociatedConstraints(),
-                                         New->getAssociatedConstraints())) {
+  const Expr *OldMismatched, *NewMismatched;
+  if (Kind != TPL_TemplateTemplateArgumentMatch &&
+      !CheckRedeclarationConstraintMatch(Old->getAssociatedConstraints(),
+                                         New->getAssociatedConstraints(),
+                                         Complain ? &OldMismatched : nullptr,
+                                         Complain ? &NewMismatched : nullptr)) {
     if (Complain)
-      DiagnoseRedeclarationConstraintMismatch(Old, New);
+      DiagnoseRedeclarationConstraintMismatch(OldMismatched ?
+                                              OldMismatched->getBeginLoc() :
+                                              Old->getTemplateLoc(),
+                                              NewMismatched ?
+                                              NewMismatched->getBeginLoc() :
+                                              New->getTemplateLoc());
     return false;
   }
 
@@ -10324,4 +10391,4 @@
     //   template-parameter:
     //     ...
     //     parameter-declaration
-    // p2
\ No newline at end of file
+    // p2
Index: lib/Sema/SemaTemplateDeduction.cpp
===================================================================
--- lib/Sema/SemaTemplateDeduction.cpp
+++ lib/Sema/SemaTemplateDeduction.cpp
@@ -4498,7 +4498,7 @@
   QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
   NamedDecl *TemplParamPtr = TemplParam;
   FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
-      Loc, Loc, TemplParamPtr, Loc, nullptr);
+      Context, Loc, Loc, TemplParamPtr, Loc, nullptr);
 
   QualType FuncParam =
       SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
@@ -4906,17 +4906,15 @@
                                  unsigned NumCallArguments2) {
 
   auto JudgeByConstraints = [&] () -> FunctionTemplateDecl * {
-    bool MoreConstrained1 = IsMoreConstrained(FT1,
-                                              FT1->getAssociatedConstraints(),
-                                              FT2,
-                                              FT2->getAssociatedConstraints());
-    bool MoreConstrained2 = IsMoreConstrained(FT2,
-                                              FT2->getAssociatedConstraints(),
-                                              FT1,
-                                              FT1->getAssociatedConstraints());
-    if (MoreConstrained1 == MoreConstrained2)
+    bool AtLeastAsConstrained1 = IsAtLeastAsConstrained(
+        FT1, FT1->getAssociatedConstraints(),
+        FT2, FT2->getAssociatedConstraints());
+    bool AtLeastAsConstrained2 = IsAtLeastAsConstrained(
+        FT2, FT2->getAssociatedConstraints(),
+        FT1, FT1->getAssociatedConstraints());
+    if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
       return nullptr;
-    return MoreConstrained1 ? FT1 : FT2;
+    return AtLeastAsConstrained1 ? FT1 : FT2;
   };
 
   bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
@@ -5134,17 +5132,15 @@
   bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
 
   if (Better1 == Better2) {
-    bool MoreConstrained1 = IsMoreConstrained(PS1,
-                                              PS1->getAssociatedConstraints(),
-                                              PS2,
-                                              PS2->getAssociatedConstraints());
-    bool MoreConstrained2 = IsMoreConstrained(PS2,
-                                              PS2->getAssociatedConstraints(),
-                                              PS1,
-                                              PS1->getAssociatedConstraints());
-    if (MoreConstrained1 == MoreConstrained2)
+    bool AtLeastAsConstrained1 = IsAtLeastAsConstrained(
+        PS1, PS1->getAssociatedConstraints(),
+        PS2, PS2->getAssociatedConstraints());
+    bool AtLeastAsConstrained2 = IsAtLeastAsConstrained(
+        PS2, PS2->getAssociatedConstraints(),
+        PS1, PS1->getAssociatedConstraints());
+    if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
       return nullptr;
-    return MoreConstrained1 ? PS1 : PS2;
+    return AtLeastAsConstrained1 ? PS1 : PS2;
   }
 
   return Better1 ? PS1 : PS2;
@@ -5156,17 +5152,15 @@
   QualType PrimaryT = Primary->getInjectedClassNameSpecialization();
   QualType PartialT = Spec->getInjectedSpecializationType();
   auto JudgeByConstraints = [&] {
-    bool MoreConstrainedPrimary = IsMoreConstrained(Primary,
-                                            Primary->getAssociatedConstraints(),
-                                            Spec,
-                                            Spec->getAssociatedConstraints());
-    bool MoreConstrainedSpec = IsMoreConstrained(Spec,
-                                           Spec->getAssociatedConstraints(),
-                                           Primary,
-                                           Primary->getAssociatedConstraints());
-    if (MoreConstrainedPrimary == MoreConstrainedSpec)
+    bool AtLeastAsConstrainedPrimary = IsAtLeastAsConstrained(
+        Primary, Primary->getAssociatedConstraints(),
+        Spec, Spec->getAssociatedConstraints());
+    bool AtLeastAsConstrainedSpec = IsAtLeastAsConstrained(
+        Spec, Spec->getAssociatedConstraints(),
+        Primary, Primary->getAssociatedConstraints());
+    if (AtLeastAsConstrainedPrimary == AtLeastAsConstrainedSpec)
       return false;
-    return MoreConstrainedSpec;
+    return AtLeastAsConstrainedSpec;
   };
   if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
     return JudgeByConstraints();
@@ -5198,18 +5192,16 @@
   bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
 
   if (Better1 == Better2) {
-    bool MoreConstrained1 = IsMoreConstrained(PS1,
-                                              PS1->getAssociatedConstraints(),
-                                              PS2,
-                                              PS2->getAssociatedConstraints());
-    bool MoreConstrained2 = IsMoreConstrained(PS2,
-                                              PS2->getAssociatedConstraints(),
-                                              PS1,
-                                              PS1->getAssociatedConstraints());
-    if (MoreConstrained1 == MoreConstrained2) {
+    bool AtLeastAsConstrained1 = IsAtLeastAsConstrained(
+        PS1, PS1->getAssociatedConstraints(),
+        PS2, PS2->getAssociatedConstraints());
+    bool AtLeastAsConstrained2 = IsAtLeastAsConstrained(
+        PS2, PS2->getAssociatedConstraints(),
+        PS1, PS1->getAssociatedConstraints());
+    if (AtLeastAsConstrained1 == AtLeastAsConstrained2) {
       return nullptr;
     }
-    return MoreConstrained1 ? PS1 : PS2;
+    return AtLeastAsConstrained1 ? PS1 : PS2;
   }
 
   return Better1 ? PS1 : PS2;
@@ -5232,17 +5224,15 @@
       CanonTemplate, Spec->getTemplateArgs().asArray());
 
   auto JudgeByConstraints = [&] {
-      bool MoreConstrainedPrimary = IsMoreConstrained(Primary,
-                                            Primary->getAssociatedConstraints(),
-                                            Spec,
-                                            Spec->getAssociatedConstraints());
-      bool MoreConstrainedSpec = IsMoreConstrained(Spec,
-                                           Spec->getAssociatedConstraints(),
-                                           Primary,
-                                           Primary->getAssociatedConstraints());
-      if (MoreConstrainedPrimary == MoreConstrainedSpec)
+      bool AtLeastAsConstrainedPrimary = IsAtLeastAsConstrained(
+          Primary, Primary->getAssociatedConstraints(),
+          Spec, Spec->getAssociatedConstraints());
+      bool AtLeastAsConstrainedSpec = IsAtLeastAsConstrained(
+          Spec, Spec->getAssociatedConstraints(),
+          Primary, Primary->getAssociatedConstraints());
+      if (AtLeastAsConstrainedPrimary == AtLeastAsConstrainedSpec)
         return false;
-      return MoreConstrainedSpec;
+      return AtLeastAsConstrainedSpec;
   };
 
   if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
@@ -5285,7 +5275,8 @@
     SFINAETrap Trap(*this);
 
     Context.getInjectedTemplateArgs(P, PArgs);
-    TemplateArgumentListInfo PArgList(P->getLAngleLoc(), P->getRAngleLoc());
+    TemplateArgumentListInfo PArgList(P->getLAngleLoc(),
+                                      P->getRAngleLoc());
     for (unsigned I = 0, N = P->size(); I != N; ++I) {
       // Unwrap packs that getInjectedTemplateArgs wrapped around pack
       // expansions, to form an "as written" argument list.
Index: lib/Sema/SemaTemplateInstantiateDecl.cpp
===================================================================
--- lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -2307,7 +2307,12 @@
       D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
       D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack());
   Inst->setAccess(AS_public);
-
+  if (Expr *CE = D->getConstraintExpression()) {
+    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
+    if (Result.isInvalid())
+      return nullptr;
+    Inst->setConstraintExpression(Result.get());
+  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     TypeSourceInfo *InstantiatedDefaultArg =
         SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
@@ -2456,6 +2461,12 @@
   if (Invalid)
     Param->setInvalidDecl();
 
+  if (Expr *CE = D->getConstraintExpression()) {
+    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
+    if (Result.isInvalid())
+      return nullptr;
+    Param->setConstraintExpression(Result.get());
+  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
@@ -2580,6 +2591,12 @@
         SemaRef.Context, Owner, D->getLocation(),
         D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
         D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
+  if (Expr *CE = D->getConstraintExpression()) {
+    ExprResult Result = SemaRef.SubstExpr(CE, TemplateArgs);
+    if (Result.isInvalid())
+      return nullptr;
+    Param->setConstraintExpression(Result.get());
+  }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     NestedNameSpecifierLoc QualifierLoc =
         D->getDefaultArgument().getTemplateQualifierLoc();
Index: lib/Serialization/ASTReaderDecl.cpp
===================================================================
--- lib/Serialization/ASTReaderDecl.cpp
+++ lib/Serialization/ASTReaderDecl.cpp
@@ -2357,6 +2357,9 @@
   D->setDeclaredWithTypename(Record.readInt());
 
   // TODO: Concepts: Constrained parameters
+  if (Record.readInt())
+    D->setConstraintExpression(Record.readExpr());
+
   if (Record.readInt())
     D->setDefaultArgument(GetTypeSourceInfo());
 }
@@ -2377,6 +2380,8 @@
     // Rest of NonTypeTemplateParmDecl.
     D->ParameterPack = Record.readInt();
     // TODO: Concepts: Constrained parameters
+    if (Record.readInt())
+      D->setConstraintExpression(Record.readExpr());
     if (Record.readInt())
       D->setDefaultArgument(Record.readExpr());
   }
@@ -2396,6 +2401,8 @@
     // Rest of TemplateTemplateParmDecl.
     // TODO: Concepts: Constrained parameters
     D->ParameterPack = Record.readInt();
+    if (Record.readInt())
+      D->setConstraintExpression(Record.readExpr());
     if (Record.readInt())
       D->setDefaultArgument(Reader.getContext(),
                             Record.readTemplateArgumentLoc());
Index: lib/Serialization/ASTWriterDecl.cpp
===================================================================
--- lib/Serialization/ASTWriterDecl.cpp
+++ lib/Serialization/ASTWriterDecl.cpp
@@ -1583,7 +1583,12 @@
   VisitTypeDecl(D);
 
   Record.push_back(D->wasDeclaredWithTypename());
-  // TODO: Concepts - constrained parameters.
+
+  Expr *CE = D->getConstraintExpression();
+  Record.push_back(CE != nullptr);
+  if (CE)
+    Record.AddStmt(CE);
+
   bool OwnsDefaultArg = D->hasDefaultArgument() &&
                         !D->defaultArgumentWasInherited();
   Record.push_back(OwnsDefaultArg);
@@ -1616,6 +1621,10 @@
     // TODO: Concepts - constrained parameters.
     // Rest of NonTypeTemplateParmDecl.
     Record.push_back(D->isParameterPack());
+    Expr *CE = D->getConstraintExpression();
+    Record.push_back(CE != nullptr);
+    if (CE)
+      Record.AddStmt(CE);
     bool OwnsDefaultArg = D->hasDefaultArgument() &&
                           !D->defaultArgumentWasInherited();
     Record.push_back(OwnsDefaultArg);
@@ -1646,6 +1655,10 @@
     // TODO: Concepts - constrained parameters.
     // Rest of TemplateTemplateParmDecl.
     Record.push_back(D->isParameterPack());
+    Expr *CE = D->getConstraintExpression();
+    Record.push_back(CE != nullptr);
+    if (CE)
+      Record.AddStmt(CE);
     bool OwnsDefaultArg = D->hasDefaultArgument() &&
                           !D->defaultArgumentWasInherited();
     Record.push_back(OwnsDefaultArg);
Index: test/CXX/concepts-ts/temp/temp.arg.template/p3.cpp
===================================================================
--- /dev/null
+++ test/CXX/concepts-ts/temp/temp.arg.template/p3.cpp
@@ -0,0 +1,25 @@
+// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+
+template<typename T> concept C = T::f();
+// expected-note@-1{{and here}}
+template<typename T> concept D = C<T> && T::g();
+template<typename T> concept F = T::f();
+// expected-note@-1{{'T::f()' in the two declarations is not considered equivalent - move it to a concept and reference it from here:}}
+template<template<C> class P> struct S1 { }; // expected-note 2{{'P' declared here}}
+
+template<C> struct X { }; // expected-note{{'X' declared here}}
+
+template<D> struct Y { }; // expected-note 2{{'Y' declared here}}
+template<typename T> struct Z { };
+template<F> struct W { }; // expected-note{{'W' declared here}}
+
+S1<X> s11;
+S1<Y> s12; // expected-error{{template template argument 'Y' must not be more constrained than template template parameter 'P'}}
+S1<Z> s13;
+S1<W> s14; // expected-error{{template template argument 'W' must not be more constrained than template template parameter 'P'}}
+
+template<template<typename> class P> struct S2 { }; // expected-note 2{{'P' declared here}}
+
+S2<X> s21; // expected-error{{template template argument 'X' must not be more constrained than template template parameter 'P'}}
+S2<Y> s22; // expected-error{{template template argument 'Y' must not be more constrained than template template parameter 'P'}}
+S2<Z> s23;
Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/class-template-decl.cpp
===================================================================
--- test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/class-template-decl.cpp
+++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/class-template-decl.cpp
@@ -7,6 +7,14 @@
 template <typename U> requires (bool(U()))
 struct A;
 
+template<typename T>
+concept C1 = true;
+
+template <C1 T> requires (bool(T()))
+struct B;
+template <C1 U> requires (bool(U()))
+struct B;
+
 } // end namespace nodiag
 
 namespace diag {
@@ -24,6 +32,14 @@
 template <typename T> requires (!0) // expected-error{{associated constraints differ in template redeclaration}}
 struct C;
 
+template<typename T>
+concept C1 = true;
+
+template <C1 T> // expected-note{{previous template declaration is here}}
+struct D;
+template <typename T> requires C1<T> // expected-error{{associated constraints differ in template redeclaration}}
+struct D;
+
 } // end namespace diag
 
 namespace nodiag {
Index: test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/p3.cpp
===================================================================
--- /dev/null
+++ test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/p3.cpp
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T>
+struct X {
+    using Y = typename T::invalid;
+};
+
+template<typename T>
+concept Invalid = X<T>{};
+
+template<typename T>
+concept False = false; // expected-note{{because 'false' evaluated to false}}
+
+template<typename T>
+concept True = true;
+
+// TODO: Concepts: Uncomment trailing requires clauses here when we have correct substitution.
+//template<True T>
+//  requires False<T>
+//void g1() requires Invalid<T>;
+//
+//using g1i = decltype(g1<int>());
+
+template<False T> // expected-note{{because 'int' does not satisfy 'False'}}
+  requires Invalid<T>
+void g2(); // requires Invalid<T>;
+// expected-note@-1{{candidate template ignored: constraints not satisfied [with T = int]}}
+
+using g2i = decltype(g2<int>());
+// expected-error@-1{{no matching function for call to 'g2'}}
\ No newline at end of file
Index: test/CXX/concepts-ts/temp/temp.param/p10.cpp
===================================================================
--- /dev/null
+++ test/CXX/concepts-ts/temp/temp.param/p10.cpp
@@ -0,0 +1,104 @@
+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T>
+concept C1 = sizeof(T) == 1;
+// expected-note@-1 2{{because 'sizeof(short) == 1' (2 == 1) evaluated to false}}
+// expected-note@-2 {{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
+
+template<C1 T> // expected-note {{because 'int' does not satisfy 'C1'}}
+using A = T;
+
+using a1 = A<int>; // expected-error {{constraints not satisfied for alias template 'A' [with T = int]}}
+using a2 = A<char>;
+
+template<typename T>
+concept C2 = sizeof(T) == 2;
+// expected-note@-1 {{because 'sizeof(char) == 2' (1 == 2) evaluated to false}}
+
+template<C1 T1, C2 T2>
+// expected-note@-1 2{{because 'short' does not satisfy 'C1'}}
+// expected-note@-2 {{because 'char' does not satisfy 'C2'}}
+using B = T1;
+
+using b1 = B<char, short>;
+using b2 = B<char, char>; // expected-error {{constraints not satisfied for alias template 'B' [with T1 = char, T2 = char]}}
+using b3 = B<short, short>; // expected-error {{constraints not satisfied for alias template 'B' [with T1 = short, T2 = short]}}
+using b4 = B<short, char>; // expected-error {{constraints not satisfied for alias template 'B' [with T1 = short, T2 = char]}}
+
+template<typename... T>
+concept C3 = (sizeof(T) + ...) == 12;
+// expected-note@-1 {{because 'sizeof(char [11]) == 12' (11 == 12) evaluated to false}}
+// expected-note@-2 {{because 'sizeof(char [10]) == 12' (10 == 12) evaluated to false}}
+// expected-note@-3 {{because 'sizeof(char [12]) + sizeof(int [3]) + sizeof(short [6]) == 12' (36 == 12) evaluated to false}}
+
+template<C3 T1, C3 T2, C3 T3>
+// expected-note@-1 {{because 'char [11]' does not satisfy 'C3'}}
+// expected-note@-2 {{because 'char [10]' does not satisfy 'C3'}}
+using C = T2;
+
+using c1 = C<char[12], int[3], short[6]>;
+using c2 = C<char[12], char[11], char[10]>;
+// expected-error@-1 {{constraints not satisfied for alias template 'C' [with T1 = char [12], T2 = char [11], T3 = char [10]]}}
+using c3 = C<char[12], char[12], char[10]>;
+// expected-error@-1 {{constraints not satisfied for alias template 'C' [with T1 = char [12], T2 = char [12], T3 = char [10]]}}
+
+template<C3... Ts>
+// expected-note@-1 {{because 'C3<char [12], int [3], short [6]>' evaluated to false}}
+using D = int;
+
+using d1 = D<char[12], int[3], short[6]>; // expected-error {{constraints not satisfied for alias template 'D' [with Ts = <char [12], int [3], short [6]>}}
+using d2 = D<int, int, int>;
+using d3 = D<short, short, short, short, short, short>;
+
+template<typename T>
+concept C4 = sizeof(T) == 4;
+// expected-note@-1 3{{because 'sizeof(char) == 4' (1 == 4) evaluated to false}}
+
+template<C4... Ts>
+// expected-note@-1 2{{because 'char' does not satisfy 'C4'}}
+// expected-note@-2 {{and 'char' does not satisfy 'C4'}}
+using E = int;
+
+using e1 = E<int>;
+using e2 = E<char, int>; // expected-error {{constraints not satisfied for alias template 'E' [with Ts = <char, int>]}}
+using e3 = E<char, char>; // expected-error {{constraints not satisfied for alias template 'E' [with Ts = <char, char>]}}
+using e4 = E<>;
+
+template<typename T, typename U>
+constexpr bool is_same_v = false;
+
+template<typename T>
+constexpr bool is_same_v<T, T> = true;
+
+template<typename T, typename U>
+concept Same = is_same_v<T, U>; // expected-note {{because 'is_same_v<long, int>' evaluated to false}}
+
+template<Same<int> T> // expected-note {{because 'Same<long, int>' evaluated to false}}
+using F = T;
+
+using f1 = F<int>;
+using f2 = F<long>; // expected-error {{constraints not satisfied for alias template 'F' [with T = long]}}
+
+template<typename T, typename... Ts>
+concept OneOf = (is_same_v<T, Ts> || ...);
+// expected-note@-1 2{{because 'is_same_v<char, char [1]>' evaluated to false}}
+// expected-note@-2 2{{and 'is_same_v<char, char [2]>' evaluated to false}}
+// expected-note@-3 {{because 'is_same_v<short, int>' evaluated to false}}
+// expected-note@-4 {{and 'is_same_v<short, long>' evaluated to false}}
+// expected-note@-5 {{and 'is_same_v<short, char>' evaluated to false}}
+
+template<OneOf<char[1], char[2]> T, OneOf<int, long, char> U>
+// expected-note@-1 2{{because 'OneOf<char, char [1], char [2]>' evaluated to false}}
+// expected-note@-2 {{because 'OneOf<short, int, long, char>' evaluated to false}}
+using G = T;
+
+using g1 = G<char[1], int>;
+using g2 = G<char, int>; // expected-error{{constraints not satisfied for alias template 'G' [with T = char, U = int]}}
+using g3 = G<char[1], short>; // expected-error{{constraints not satisfied for alias template 'G' [with T = char [1], U = short]}}
+using g4 = G<char, short>; // expected-error{{constraints not satisfied for alias template 'G' [with T = char, U = short]}}
+
+template<OneOf<char[1], char[2]>... Ts>
+using H = int;
+
+using h1 = H<char[1], int>;
+using h2 = H<int, int>;
Index: test/Parser/cxx-constrained-template-param-with-partial-id.cpp
===================================================================
--- /dev/null
+++ test/Parser/cxx-constrained-template-param-with-partial-id.cpp
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+template<typename T, int a>
+concept C1 = true;
+
+template<C1 T> // expected-error {{concept 'C1' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}} expected-error{{explicit specialization of alias templates is not permitted}}
+using badA = T[10];
+
+template<C1<0> T>
+using A = T[10];
+
+using a = A<int>;
+
+namespace ns {
+  template<typename T, typename U, typename... X>
+  concept C2 = true;
+}
+
+template<ns::C2 T1, ::ns::C2 T2> // expected-error 2{{concept 'C2' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}}
+requires (sizeof(T1) <= sizeof(T2)) // expected-error{{expected unqualified-id}}
+struct badB { };
+
+template<ns::C2<int> T1, ::ns::C2<char, T1> T2>
+  requires (sizeof(T1) <= sizeof(T2))
+struct B { };
+
+using b = B<int, int>;
+
+template<ns::C2... T1> // expected-error {{concept 'C2' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}} expected-error{{extraneous 'template<>' in declaration of struct 'badC'}}
+struct badC { };
+
+template<ns::C2<int>... T1>
+struct C { };
+
+using c1 = C<char, char, char>;
+using c2 = C<char, char, char, char>;
\ No newline at end of file
Index: test/Parser/cxx-constrained-template-param.cpp
===================================================================
--- /dev/null
+++ test/Parser/cxx-constrained-template-param.cpp
@@ -0,0 +1,90 @@
+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+// expected-no-diagnostics
+
+namespace type
+{
+  template<typename T>
+  concept C1 = true;
+
+  template<C1 T, C1 U = int>
+  using A = T[10];
+
+  using a = A<int>;
+
+  namespace ns {
+    template<typename T, int a = 0>
+    concept C2 = true;
+  }
+
+  template<ns::C2 T1, ::type::ns::C2 T2> requires (sizeof(T1) <= sizeof(T2))
+  struct B { };
+
+  using b = B<int, int>;
+
+  template<ns::C2... T1>
+  struct C { };
+
+  using c1 = C<char, char, char>;
+  using c2 = C<char, char, char, char>;
+}
+
+namespace non_type
+{
+  template<int v>
+  concept C1 = true;
+
+  template<C1 v, C1 u = 0>
+  int A = v;
+
+  int& a = A<1>;
+
+  namespace ns {
+    template<bool x, typename T = int>
+    concept C2 = true;
+  }
+
+  template<ns::C2 v1, ::non_type::ns::C2 v2> requires (sizeof(v1) <= sizeof(v2))
+  struct B { };
+
+  using b = B<true, false>;
+
+  template<ns::C2... T1>
+  struct C { };
+
+  using c1 = C<false, true, false>;
+  using c2 = C<false, true, false, false>;
+}
+
+namespace temp
+{
+  template<typename>
+  struct test1 { };
+
+  template<typename>
+  struct test2 { };
+
+  template<template<typename> typename T>
+  concept C1 = true;
+
+  template<C1 TT, C1 UU = test1>
+  using A = TT<int>;
+
+  using a = A<test1>;
+
+  namespace ns {
+    template<template<typename> typename... TT>
+    concept C2 = true;
+  }
+
+  template<ns::C2 TT1, ::temp::ns::C2 TT2>
+    requires (sizeof(TT1<int>) <= sizeof(TT2<int>))
+  struct B { };
+
+  using b = B<test1, test2>;
+
+  template<ns::C2... T1>
+  struct C { };
+
+  using c1 = C<test1>;
+  using c2 = C<test1, test2, test2>;
+}
\ No newline at end of file
Index: tools/libclang/CIndex.cpp
===================================================================
--- tools/libclang/CIndex.cpp
+++ tools/libclang/CIndex.cpp
@@ -752,6 +752,10 @@
 }
 
 bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
+  if (Expr *CE = D->getConstraintExpression())
+    if (Visit(MakeCXCursor(CE, StmtParent, TU, RegionOfInterest)))
+      return true;
+
   // Visit the default argument.
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
@@ -916,6 +920,10 @@
 bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
   if (VisitDeclaratorDecl(D))
     return true;
+
+  if (Expr *CE = D->getConstraintExpression())
+    if (Visit(MakeCXCursor(CE, StmtParent, TU, RegionOfInterest)))
+      return true;
   
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     if (Expr *DefArg = D->getDefaultArgument())
@@ -947,7 +955,11 @@
 bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
   if (VisitTemplateParameters(D->getTemplateParameters()))
     return true;
-  
+
+  if (Expr *CE = D->getConstraintExpression())
+    if (Visit(MakeCXCursor(CE, StmtParent, TU, RegionOfInterest)))
+      return true;
+
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
       VisitTemplateArgumentLoc(D->getDefaultArgument()))
     return true;