[Concepts] Constrained partial specializations and function overloads.

[saar.raz]

Summary

Added support for constraint satisfaction checking and partial ordering of constraints in constrained partial specialization and function template overloads. Depends on D41569.

[saar.raz]

• Correct handling of non-substitutable concept specialization expressions.

[saar.raz]

• Adjusted constraint normalization to piecewise constraint substitution
• Normalized constraints are now represented as described in the standard (a non-substituted expression along with a list of "template arguments").

[saar.raz]

Adjusted to switch to ASTTemplateArgumentListInfo

[saar.raz]

• Fix bad handling of checking of deduced arguments in function templates

[saar.raz]

• Moved constraint checks to the end of FinishTemplateArgumentDeduction

[saar.raz]

Fixed bug in normalization substitution into CSEs
Rebase onto trunk

[martong]

lib/AST/ASTImporter.cpp

5026 ↗

(On Diff #195010)

ClassTemplate is in the "to" context, i.e. it is already imported.
PartialSpec is in the "from" context, not yet imported.
Thus, findPartialSpecialization is going search for a specialization in the "to" context but with constraints which are in the "from" context. So I suppose this will not find any match.
So, first you have to import the associated constraints expression and then use that in the search.

Something like:

ExpectedExpr ConstraintsOrErr = import(D->getAssociatedConstraints());
if (!ConstraintsOrErr)
  return ConstraintsOrErr.takeError();
// ...
ClassTemplate->findPartialSpecialization(TemplateArgs,
          *ConstraintsOrErr, InsertPos);

(The same below.)

[balazske]

lib/AST/ASTImporter.cpp

5096 ↗

(On Diff #195010)

This looks correct: PartSpec is the new instance (but this is not the best name for it, maybe PartialSpec2?).
But: How are the "associated constraint" expressions imported (stored somewhere in the To context)?

[saar.raz]

• Fixed importing of ACs when importing partial specs.
• Adjust to getAssociatedConstraints interface change

[saar.raz]

Renamed PartSpec to PartSpec2 (CR)

[martong]

From the ASTImporter point of view it looks good to me, thanks for the changes!

[rsmith]

(Didn't finish the review, but I have to run now.)

include/clang/AST/DeclTemplate.h

770

ProfileArguments &&...ProfileArgs?

2024–2040

Hmm, is this the right set of things to be profiling? The relevant rule should be that the template-heads are equivalent and the simple-template-ids are equivalent, and checking the associated constraints isn't sufficient to check the former. Should we be profiling the template parameter list and template arguments instead?

include/clang/Basic/DiagnosticSemaKinds.td

2426–2427

Please don't join sentences with periods like this; it looks strange given that we generally render diagnostics in lowercase, and not as full sentences). I'm also not sure what the second sentence here is telling the user. (What do you mean by "any"? "some", or "all", or substitutions the program requires, or something else?)

We generally use "while" not "when" for these "here's what I was doing" notes.

lib/Sema/SemaConcept.cpp

447–449

The specification says we substitute into the parameter mapping bottom-up (starting with atomic constraints and then substituting as they get used in enclosing constraints), but you're substituting top-down. That's not equivalent: specifically, the rules say that we should not perform substitution for parameters that are not used in the expansion of a concept ([temp.constr.atomic]p1: "[...] a mapping from the template parameters that appear within E to template arguments involving the [...]"). Example:

template<typename T> concept True = true;
template<typename T> concept Foo = True<T*>;
template<typename T> concept Bar = Foo<T&>;
template<typename T> void f() requires Bar<T>;

Here, the true atomic constraint has no parameter mappings, so we should never perform the substitution that would form T&*, and so shouldn't reject this for forming a pointer to a reference.

I think it's sufficient to first determine which parameters are used in a concept (perhaps when the concept is defined), and then form a parameter mapping top-down skipping the unused arguments, but you need to be careful to do that recursively (Bar doesn't use its T because Foo doesn't use its T).

740–741

There are a bunch of ways we can optimize this, but let's get the straightforward approach landed first :)

lib/Sema/SemaTemplate.cpp

3598

&& and || on prior line, please.

[saar.raz]

Address all CR comments by rsmith (including rewrite of normalization).
Decided to not support things like:

template<typename T, typename U>
concept C = ...;

template<typename... T> requires C<T...>
struct S { };

For now, as wording is not clear what the normal form of these should be.

[saar.raz]

Addressed in latest diff

[rsmith]

Only a few non-nit comments; if you feel confident addressing those, please feel free to commit after doing so. (If you'd like another round of review, let me know.) Thanks!

clang/include/clang/AST/DeclTemplate.h

796–799 ↗

(On Diff #232457)

Formatting nits:

typename ...ProfileArguments
ProfileArguments &&...ProfileArgs

clang/include/clang/Basic/DiagnosticSemaKinds.td

2507 ↗

(On Diff #232457)

Consider adding "during constraint normalization" before the semicolon.

Giving advice here ("make sure [...]") isn't consistent with our normal diagnostic style, which is to present facts. I wonder if we can rephrase this as a fact? Something like "while substituting into %0 %1; constraint normalization is not a SFINAE context" would work -- though I don't think we mention SFINAE in any diagnostics yet either, and I'd prefer not to, if possible.

Maybe just "while substituting into %0 %1 during constraint normalization" is enough; the fact that we're issuing an error for a substitution failure seems to strongly imply that substitution failure in this context is an error. What do you think?

clang/include/clang/Sema/Sema.h

6036 ↗

(On Diff #232457)

Nit: underindented.

clang/lib/AST/DeclTemplate.cpp

432 ↗

(On Diff #232457)

Nit: parameters after a newline should start in the same column as the first parameter. (Either flow Args onto a new line or indent these parameters to line up with it.)

445–463 ↗

(On Diff #232457)

Should we profile the kind of the template parameter (non-type/type/template) here? The profiling for the different kinds seems like it might not actually collide in practice, but that looks like it's happening by luck rather than by design.

Conversely, can we remove the profiling of the depth and index? That seems like it should be implied by the position of the parameter in the profiling data.

clang/lib/Sema/SemaConcept.cpp

417 ↗

(On Diff #232457)

Nit: we generally don't use direct-list-initialization. Use parens here.

528–569 ↗

(On Diff #232457)

You can use Sema::MarkUsedTemplateParameters for this.

... oh, except that it's broken for this case and has a FIXME to walk the full expression in OnlyDeduced = false mode:

// FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
// find other occurrences of template parameters.

Oops. Please either move this into MarkUsedTemplateParameters and call that from here, or at least add a FIXME here to remind us to do so.

clang/lib/Sema/SemaTemplate.cpp

10521–10526 ↗

(On Diff #232457)

Presumably this is unintentional / left behind from editing?

clang/lib/Sema/SemaTemplateDeduction.cpp

2505 ↗

(On Diff #232457)

Is there any code that can be shared between this and ASTContext::getInjectedTemplateArg? (I think probably not, because that creates pack expansions and we don't want them here, but it seems worth considering.)

2514 ↗

(On Diff #232457)

VK_RValue is wrong here: we want an lvalue for a reference parameter. getInjectedTemplateArg uses Expr::getValueKindForType(NTTP->getType()) rather than VK_RValue, but can you add a NonTypeTemplateParmDecl::getValueKindForRef or similar, and use that both there and here, so that we don't need to track down all these places again when adding class type non-type template parameters?

Also NTTP->getType() is wrong in the reference type case (you want getNonLValueExprType).

Alternatively, you could use BuildDeclarationNameExpr, which computes the type and value kind for you. (getInjectedTemplateArg can't do that, because it's not in Sema.)

2739 ↗

(On Diff #232457)

Nit: || on the previous line, please.

5158 ↗

(On Diff #232457)

This should only apply if Better1 and Better2 are both true.

(Eventually -- once the relevant core issue is fixed -- we'll want to use the deductions from the "at least as specialized" checks as inputs to the "more constrained" checks too -- we should substitute those deductions into the normalized constraints prior to checking which is more constrained, so that we're talking about constraints on the same parameters in both sets of constraints. But let's not jump the gun on that.)

5190 ↗

(On Diff #232457)

As above, this should still return false.

5218 ↗

(On Diff #232457)

Likewise here.

5263 ↗

(On Diff #232457)

And here.

[thakis]

This makes clang crash when running tests: http://45.33.8.238/linux/5976/step_7.txt

Please use "Differential Revision: https://reviews.llvm.org/D41910" instead of "Phabricator: D41910" so that phab auto-closes the review and other auto-linking tools work.

[rnk]

This was relanded and reverted again today (d3f5769d5e93b30d4a8b4696381d5e4a304992fa & 79cc9e9b304a90598e8def4c8b5354d1f99186eb). I got this reduction:

template <unsigned> struct a {};
struct DestructibleUnionImpl {
  template <class...> DestructibleUnionImpl(a<0>);
  template <unsigned b, class...> DestructibleUnionImpl(a<b>);
};
class c {
  c() : d(a<0>()) {}
  DestructibleUnionImpl d;
};

Compile with clang -cc1, get this assertion:
clang: /usr/local/google/home/rnk/bisect-llvm-project/llvm/include/llvm/ADT/SmallBitVector.h:452: llvm::SmallBitVector::reference llvm::SmallBitVector::operator[](unsigned int): Assertion `Idx < size() && "Out-of-bounds Bit access."' failed.

Please add this as a test when relanding.

include/clang/AST/DeclTemplate.h

protected:
   template <typename EntryType>
   static SpecIterator<EntryType>
   makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {
     return SpecIterator<EntryType>(isEnd ? Specs.end() : Specs.begin());
   }
 
   void loadLazySpecializationsImpl() const;
 
-  template <class EntryType> typename SpecEntryTraits<EntryType>::DeclType*
+  template <class EntryType, typename... ProfileArguments>
+  typename SpecEntryTraits<EntryType>::DeclType*
   findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
-                         ArrayRef<TemplateArgument> Args, void *&InsertPos);
+                         void *&InsertPos, ProfileArguments... ProfileArgs);
 
   template <class Derived, class EntryType>
   void addSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs,
                              EntryType *Entry, void *InsertPos);
 
   struct CommonBase {
     CommonBase() : InstantiatedFromMember(nullptr, false) {}
 
TemplateParameterList *getTemplateParameters() const {
     return CTDI ? CTDI->getTemplateParameters()
                 : TemplateParams.getPointer().get<TemplateParameterList *>();
   }
 
   /// \brief Get the total constraint-expression associated with this template,
   /// including constraint-expressions derived from the requires-clause,
   /// trailing requires-clause (for functions and methods) and constrained
   /// template parameters.
-  Expr *getAssociatedConstraints();
+  Expr *getAssociatedConstraints() const;
 
   /// Get the template arguments as written.
   const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
     return ArgsAsWritten;
   }
 
   /// \brief Retrieve the member class template partial specialization from
   /// which this particular class template partial specialization was
public:
   /// specialization.  This is not the same as the type-decl-type for
   /// this partial specialization, which is an InjectedClassNameType.
   QualType getInjectedSpecializationType() const {
     assert(getTypeForDecl() && "partial specialization has no type set!");
     return cast<InjectedClassNameType>(getTypeForDecl())
              ->getInjectedSpecializationType();
   }
 
-  // FIXME: Add Profile support!
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, getTemplateArgs().asArray(), getAssociatedConstraints(),
+            getASTContext());
+  }
+
+  static void
+  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
+          Expr *AssociatedConstraints, ASTContext &Context) {
+    ID.AddInteger(TemplateArgs.size());
+    for (const TemplateArgument &TemplateArg : TemplateArgs)
+      TemplateArg.Profile(ID, Context);
+    ID.AddBoolean(AssociatedConstraints != nullptr);
+    if (AssociatedConstraints) {
+        AssociatedConstraints->Profile(ID, Context, /*Canonical=*/true);
+    }
+  }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 
   static bool classofKind(Kind K) {
     return K == ClassTemplatePartialSpecialization;
   }
 };
 
 /// Declaration of a class template.
public:
   ClassTemplateDecl *getInstantiatedFromMemberTemplate() const {
     return cast_or_null<ClassTemplateDecl>(
              RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
   }
 
   /// \brief Return the partial specialization with the provided arguments if it
   /// exists, otherwise return the insertion point.
   ClassTemplatePartialSpecializationDecl *
-  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
+  findPartialSpecialization(ArrayRef<TemplateArgument> Args,
+                            Expr *AssociatedConstraints, void *&InsertPos);
 
   /// \brief Insert the specified partial specialization knowing that it is not
   /// already in. InsertPos must be obtained from findPartialSpecialization.
   void AddPartialSpecialization(ClassTemplatePartialSpecializationDecl *D,
                                 void *InsertPos);
 
   /// \brief Retrieve the partial specializations as an ordered list.
   void getPartialSpecializations(
public:
   const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
     return ArgsAsWritten;
   }
 
   /// \brief Get the total constraint-expression associated with this template,
   /// including constraint-expressions derived from the requires-clause,
   /// trailing requires-clause (for functions and methods) and constrained
   /// template parameters.
-  Expr *getAssociatedConstraints();
+  Expr *getAssociatedConstraints() const;
 
   /// \brief Retrieve the member variable template partial specialization from
   /// which this particular variable template partial specialization was
   /// instantiated.
   ///
   /// \code
   /// template<typename T>
   /// struct Outer {
public:
   void setMemberSpecialization() {
     VarTemplatePartialSpecializationDecl *First =
         cast<VarTemplatePartialSpecializationDecl>(getFirstDecl());
     assert(First->InstantiatedFromMember.getPointer() &&
            "Only member templates can be member template specializations");
     return First->InstantiatedFromMember.setInt(true);
   }
 
+  void Profile(llvm::FoldingSetNodeID &ID) const {
+    Profile(ID, getTemplateArgs().asArray(), getAssociatedConstraints(),
+            getASTContext());
+  }
+
+  static void
+  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
+          Expr *AssociatedConstraints, ASTContext &Context) {
+    ID.AddInteger(TemplateArgs.size());
+    for (const TemplateArgument &TemplateArg : TemplateArgs)
+      TemplateArg.Profile(ID, Context);
+    ID.AddBoolean(AssociatedConstraints != nullptr);
+    if (AssociatedConstraints) {
+        AssociatedConstraints->Profile(ID, Context, /*Canonical=*/true);
+    }
+  }
+
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
 
   static bool classofKind(Kind K) {
     return K == VarTemplatePartialSpecialization;
   }
 };
 
 /// Declaration of a variable template.
public:
   VarTemplateDecl *getInstantiatedFromMemberTemplate() const {
     return cast_or_null<VarTemplateDecl>(
         RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate());
   }
 
   /// \brief Return the partial specialization with the provided arguments if it
   /// exists, otherwise return the insertion point.
   VarTemplatePartialSpecializationDecl *
-  findPartialSpecialization(ArrayRef<TemplateArgument> Args, void *&InsertPos);
+  findPartialSpecialization(ArrayRef<TemplateArgument> Args,
+                            Expr *AssociatedConstraints, void *&InsertPos);
 
   /// \brief Insert the specified partial specialization knowing that it is not
   /// already in. InsertPos must be obtained from findPartialSpecialization.
   void AddPartialSpecialization(VarTemplatePartialSpecializationDecl *D,
                                 void *InsertPos);
 
   /// \brief Retrieve the partial specializations as an ordered list.
   void getPartialSpecializations(

include/clang/Basic/DiagnosticSemaKinds.td

 def note_atomic_constraint_evaluated_to_false : Note<
   "%select{and |because }0'%1' evaluated to false">;
 def note_concept_specialization_constraint_evaluated_to_false : Note<
   "%select{and |because }0'%1' evaluated to false">;
 def note_single_arg_concept_specialization_constraint_evaluated_to_false : Note<
   "%select{and |because }0%1 does not satisfy %2">;
 def note_atomic_constraint_evaluated_to_false_elaborated : Note<
   "%select{and |because }0'%1' (%2 %3 %4) evaluated to false">;
-def err_could_not_normalize_ill_formed_constraint : Error<
-  "required expansion of concept specialization %0 failed, substituted "
-  "expression would be illegal">;
-def note_could_not_normalize_ill_formed_constraint_reason : Note<
-  "because: %0">;
+def note_could_not_normalize_argument_substitution_failed : Note<
+  "could not substitute template arguments into %0 %1. "
+  "Template arguments to a concept specialization expression must be valid "
+  "expressions">;
+def note_could_not_normalize_unmatched_argument_list_after_subst : Note<
+  "could not substitute template arguments into %0 %1 - the resulting template "
+  "argument list does not match the concept's parameter list">;
 
 def err_template_different_associated_constraints : Error<
   "associated constraints differ in template redeclaration">;
 
 // C++11 char16_t/char32_t
 def warn_cxx98_compat_unicode_type : Warning<
   "'%0' type specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;

include/clang/Sema/Sema.h

   CreateConceptSpecializationExpr(SourceLocation ConceptNameLoc,
                                   ConceptDecl *CD,
                                   const TemplateArgumentListInfo *TALI);
 
   /// \brief Check whether the given expression is a valid constraint
   /// expression. A diagnostic is emitted if it is not, and false is returned.
   bool CheckConstraintExpression(Expr *CE);
 
+private:
+  /// \brief Caches pairs of template-like decls whose associated constraints
+  /// were checked for subsumption and whether or not the first's constraints
+  /// did in fact subsume the second's.
+  llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;
+
+public:
+  /// \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, Expr *AC1, NamedDecl *D2, Expr *AC2);
 
   /// \brief Check whether the given constraint expression is satisfied given
   /// template arguments. Returns false and updates IsSatisfied with the
   /// satisfaction verdict if successful, emits a diagnostic and returns true if
   /// an error occured and satisfaction could not be determined.
   ///
   /// \param SubstitutedExpr if not null, will be used to return the substituted
   /// constraint expression (to be used for diagnostics, for example).
public:
   void
   DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction);
 
   /// \brief Emit diagnostics explaining why a constraint expression was deemed
   /// unsatisfied because it was ill-formed.
   void DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLocation,
                                               StringRef Diagnostic);
 
+  void DiagnoseRedeclarationConstraintMismatch(const TemplateParameterList *Old,
+                                              const TemplateParameterList *New);
+
   // ParseObjCStringLiteral - Parse Objective-C string literals.
   ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
                                     ArrayRef<Expr *> Strings);
 
   ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
 
   /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
   /// numeric literal expression. Type of the expression will be "NSNumber *"

lib/AST/ASTContext.cpp

else if (NonTypeTemplateParmDecl *NTTP
       }
       CanonParams.push_back(Param);
 
     } else
       CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
                                            cast<TemplateTemplateParmDecl>(*P)));
   }
 
-  assert(!TTP->getRequiresClause() &&
+  assert(!TTP->getTemplateParameters()->getRequiresClause() &&
          "Unexpected requires-clause on template template-parameter");
   Expr *const CanonRequiresClause = nullptr;
 
   TemplateTemplateParmDecl *CanonTTP
     = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 
                                        SourceLocation(), TTP->getDepth(),
                                        TTP->getPosition(), 
                                        TTP->isParameterPack(),

lib/AST/DeclTemplate.cpp

if (CommonBasePtr->LazySpecializations) {
     ASTContext &Context = getASTContext();
     uint32_t *Specs = CommonBasePtr->LazySpecializations;
     CommonBasePtr->LazySpecializations = nullptr;
     for (uint32_t I = 0, N = *Specs++; I != N; ++I)
       (void)Context.getExternalSource()->GetExternalDecl(Specs[I]);
   }
 }
 
-template<class EntryType>
+template<class EntryType, typename... ProfileArguments>
 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
 RedeclarableTemplateDecl::findSpecializationImpl(
-    llvm::FoldingSetVector<EntryType> &Specs, ArrayRef<TemplateArgument> Args,
-    void *&InsertPos) {
+    llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos,
+    ProfileArguments... ProfileArgs) {
   using SETraits = SpecEntryTraits<EntryType>;
 
   llvm::FoldingSetNodeID ID;
-  EntryType::Profile(ID, Args, getASTContext());
+  EntryType::Profile(ID, ProfileArgs..., getASTContext());
   EntryType *Entry = Specs.FindNodeOrInsertPos(ID, InsertPos);
   return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
 }
 
 template<class Derived, class EntryType>
 void RedeclarableTemplateDecl::addSpecializationImpl(
     llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
     void *InsertPos) {
   using SETraits = SpecEntryTraits<EntryType>;
 
   if (InsertPos) {
 #ifndef NDEBUG
     void *CorrectInsertPos;
     assert(!findSpecializationImpl(Specializations,
-                                   SETraits::getTemplateArgs(Entry),
-                                   CorrectInsertPos) &&
+                                   CorrectInsertPos,
+                                   SETraits::getTemplateArgs(Entry)) &&
            InsertPos == CorrectInsertPos &&
            "given incorrect InsertPos for specialization");
 #endif
     Specializations.InsertNode(Entry, InsertPos);
   } else {
     EntryType *Existing = Specializations.GetOrInsertNode(Entry);
     (void)Existing;
     assert(SETraits::getDecl(Existing)->isCanonicalDecl() &&

 FunctionTemplateDecl::getSpecializations() const {
   LoadLazySpecializations();
   return getCommonPtr()->Specializations;
 }
 
 FunctionDecl *
 FunctionTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                          void *&InsertPos) {
-  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
+  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
 }
 
 void FunctionTemplateDecl::addSpecialization(
       FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
   addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
                                               InsertPos);
 }
 
ClassTemplateDecl::newCommon(ASTContext &C) const {
   Common *CommonPtr = new (C) Common;
   C.addDestruction(CommonPtr);
   return CommonPtr;
 }
 
 ClassTemplateSpecializationDecl *
 ClassTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                       void *&InsertPos) {
-  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
+  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
 }
 
 void ClassTemplateDecl::AddSpecialization(ClassTemplateSpecializationDecl *D,
                                           void *InsertPos) {
   addSpecializationImpl<ClassTemplateDecl>(getSpecializations(), D, InsertPos);
 }
 
 ClassTemplatePartialSpecializationDecl *
 ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
+                                             Expr *AssociatedConstraints,
                                              void *&InsertPos) {
-  return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
+  return findSpecializationImpl(getPartialSpecializations(), InsertPos,
+                                Args, AssociatedConstraints);
 }
 
 void ClassTemplateDecl::AddPartialSpecialization(
                                       ClassTemplatePartialSpecializationDecl *D,
                                       void *InsertPos) {
   if (InsertPos)
     getPartialSpecializations().InsertNode(D, InsertPos);
   else {

 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID) {
   ClassTemplatePartialSpecializationDecl *Result =
       new (C, ID) ClassTemplatePartialSpecializationDecl(C);
   Result->MayHaveOutOfDateDef = false;
   return Result;
 }
 
-Expr* ClassTemplatePartialSpecializationDecl::getAssociatedConstraints() {
+Expr* ClassTemplatePartialSpecializationDecl::getAssociatedConstraints() const {
   return getOrCollectAssociatedConstraints(getASTContext(),
-           cast<ClassTemplatePartialSpecializationDecl>(getCanonicalDecl())
+           const_cast<ClassTemplatePartialSpecializationDecl*>(
+              cast<ClassTemplatePartialSpecializationDecl>(getCanonicalDecl()))
              ->TemplateParams);
 }
 
 //===----------------------------------------------------------------------===//
 // FriendTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
 void FriendTemplateDecl::anchor() {}
VarTemplateDecl::newCommon(ASTContext &C) const {
   Common *CommonPtr = new (C) Common;
   C.addDestruction(CommonPtr);
   return CommonPtr;
 }
 
 VarTemplateSpecializationDecl *
 VarTemplateDecl::findSpecialization(ArrayRef<TemplateArgument> Args,
                                     void *&InsertPos) {
-  return findSpecializationImpl(getSpecializations(), Args, InsertPos);
+  return findSpecializationImpl(getSpecializations(), InsertPos, Args);
 }
 
 void VarTemplateDecl::AddSpecialization(VarTemplateSpecializationDecl *D,
                                         void *InsertPos) {
   addSpecializationImpl<VarTemplateDecl>(getSpecializations(), D, InsertPos);
 }
 
 VarTemplatePartialSpecializationDecl *
 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
+                                           Expr *AssociatedConstraints,
                                            void *&InsertPos) {
-  return findSpecializationImpl(getPartialSpecializations(), Args, InsertPos);
+  return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
+                                AssociatedConstraints);
 }
 
 void VarTemplateDecl::AddPartialSpecialization(
     VarTemplatePartialSpecializationDecl *D, void *InsertPos) {
   if (InsertPos)
     getPartialSpecializations().InsertNode(D, InsertPos);
   else {
     VarTemplatePartialSpecializationDecl *Existing =

 }
 
 VarTemplatePartialSpecializationDecl *
 VarTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                          unsigned ID) {
   return new (C, ID) VarTemplatePartialSpecializationDecl(C);
 }
 
-Expr* VarTemplatePartialSpecializationDecl::getAssociatedConstraints() {
+Expr* VarTemplatePartialSpecializationDecl::getAssociatedConstraints() const {
   return getOrCollectAssociatedConstraints(getASTContext(),
-           cast<VarTemplatePartialSpecializationDecl>(getCanonicalDecl())
+           const_cast<VarTemplatePartialSpecializationDecl*>(
+             cast<VarTemplatePartialSpecializationDecl>(getCanonicalDecl()))
              ->TemplateParams);
 }
 
 static TemplateParameterList *
 createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
   // typename T
   auto *T = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,

lib/Sema/SemaConcept.cpp

if (NewAC && OldAC) {
     NewAC->Profile(NewACInfo, Context, /*Canonical=*/true);
     OldAC->Profile(OldACInfo, Context, /*Canonical=*/true);
     if (NewACInfo == OldACInfo)
       return true; // All good; no mismatch.
   }
   return false;
 }
 
+void
+Sema::DiagnoseRedeclarationConstraintMismatch(const TemplateParameterList *Old,
+                                              const TemplateParameterList *New){
+  Diag(New->getTemplateLoc(),
+       diag::err_template_different_associated_constraints);
+
+  Diag(Old->getTemplateLoc(), diag::note_template_prev_declaration)
+        << /*declaration*/0;
+}
+
 template<typename TemplateDeclT>
 static bool
 calculateConstraintSatisfaction(Sema& S, TemplateDeclT *Template,
                                 ArrayRef<TemplateArgument> TemplateArgs,
                                 SourceLocation TemplateNameLoc,
                                 MultiLevelTemplateArgumentList &MLTAL,
                                 const Expr *ConstraintExpr,
                                 ConstraintSatisfaction &Satisfaction) {
void Sema::DiagnoseUnsatisfiedConstraint(
     const ConstraintSatisfaction& Satisfaction) {
   assert(!Satisfaction.IsSatisfied &&
          "Attempted to diagnose a satisfied constraint");
   bool First = true;
   for (auto &Pair : Satisfaction.Details) {
     diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First);
     First = false;
   }
+}
+namespace {
+struct AtomicConstraint {
+  AtomicConstraint(Expr *ConstraintExpr,
+      const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) :
+      ConstraintExpr{ConstraintExpr}, ParameterMapping{ParameterMapping} {}
+
+  bool subsumes(ASTContext &C, const AtomicConstraint &Other) const {
+    // C++ [temp.constr.order] p2
+    //   - an atomic constraint A subsumes another atomic constraint B
+    //     if and only if the A and B are identical [...]
+    //
+    // C++ [temp.constr.atomic] p2
+    //   Two atomic constraints are identical if they are formed from the
+    //   same expression and the targets of the parameter mappings are
+    //   equivalent according to the rules for expressions [...]
+
+    // We do not actually substitute the parameter mappings, therefore the
+    // constraint expressions are the originals, and comparing them will
+    // suffice.
+    if (ConstraintExpr != Other.ConstraintExpr)
+      return false;
+
+    // Check that the parameter lists are identical
+    if ((!ParameterMapping) != (!Other.ParameterMapping))
+      return false;
+    if (!ParameterMapping)
+      return true;
+    if (ParameterMapping->NumTemplateArgs !=
+        Other.ParameterMapping->NumTemplateArgs)
+      return false;
+
+    for (unsigned I = 0, S = ParameterMapping->NumTemplateArgs; I < S; ++I)
+      if (!C.getCanonicalTemplateArgument(
+                ParameterMapping->arguments()[I].getArgument())
+               .structurallyEquals(C.getCanonicalTemplateArgument(
+                   Other.ParameterMapping->arguments()[I].getArgument())))
+        return false;
+
+
+    return true;
+  }
+
+  Expr *ConstraintExpr;
+  const ASTTemplateArgumentListInfo *ParameterMapping;
+};
+
+class NormalizedConstraint {
+public:
+  enum CompoundConstraintKind { CCK_Conjunction, CCK_Disjunction };
+
+private:
+  using CompoundConstraint = llvm::PointerIntPair<
+      std::pair<NormalizedConstraint, NormalizedConstraint> *, 1,
+      CompoundConstraintKind>;
+
+  llvm::PointerUnion<AtomicConstraint *, CompoundConstraint> Constraint;
+
+  NormalizedConstraint(AtomicConstraint *C) : Constraint{C} {};
+  NormalizedConstraint(ASTContext &C, NormalizedConstraint LHS,
+                       NormalizedConstraint RHS, CompoundConstraintKind Kind)
+      : Constraint{CompoundConstraint{
+            new std::pair<NormalizedConstraint, NormalizedConstraint>{LHS, RHS},
+            Kind}} {};
+
+public:
+  CompoundConstraintKind getCompoundKind() const {
+    assert(!isAtomic() && "getCompoundKind called on atomic constraint.");
+    return Constraint.get<CompoundConstraint>().getInt();
+  }
+
+  bool isAtomic() const { return Constraint.is<AtomicConstraint *>(); }
+
+  NormalizedConstraint &getLHS() const {
+    assert(!isAtomic() && "getLHS called on atomic constraint.");
+    return Constraint.get<CompoundConstraint>().getPointer()->first;
+  }
+
+  NormalizedConstraint &getRHS() const {
+    assert(!isAtomic() && "getRHS called on atomic constraint.");
+    return Constraint.get<CompoundConstraint>().getPointer()->second;
+  }
+
+  AtomicConstraint *getAtomicConstraint() const {
+    assert(isAtomic() &&
+           "getAtomicConstraint called on non-atomic constraint.");
+    return Constraint.get<AtomicConstraint *>();
+  }
+  static llvm::Optional<NormalizedConstraint> fromConstraintExpr(
+      Sema &S, Expr *E, TemplateDecl *TD = nullptr,
+      const ASTTemplateArgumentListInfo *ParameterMapping = nullptr) {
+    assert(E != nullptr);
+
+    // C++ [temp.constr.normal]p1.1
+    // - The normal form of an expression (E) is the normal form of E.
+    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
+      return fromConstraintExpr(S, P->getSubExpr(), TD, ParameterMapping);
+    if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+      if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) {
+        auto LHS = fromConstraintExpr(S, BO->getLHS(), TD, ParameterMapping);
+        if (!LHS)
+          return llvm::Optional<NormalizedConstraint>{};
+        auto RHS = fromConstraintExpr(S, BO->getRHS(), TD, ParameterMapping);
+        if (!RHS)
+          return llvm::Optional<NormalizedConstraint>{};
+
+        return NormalizedConstraint(
+            S.Context, *LHS, *RHS,
+            BO->getOpcode() == BO_LAnd ? CCK_Conjunction : CCK_Disjunction);
+      }
+    } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) {
+      const ASTTemplateArgumentListInfo *Mapping =
+          CSE->getTemplateArgumentListInfo();
+      if (!ParameterMapping) {
+        llvm::SmallVector<TemplateArgument, 4> TempList;
+        bool InstantiationDependent = false;
+        TemplateArgumentListInfo TALI(Mapping->LAngleLoc, Mapping->RAngleLoc);
+        for (auto &Arg : Mapping->arguments())
+          TALI.addArgument(Arg);
+        bool Failed = S.CheckTemplateArgumentList(CSE->getNamedConcept(),
+            E->getLocStart(), TALI, /*PartialTemplateArgs=*/false, TempList,
+            /*UpdateArgsWithConversions=*/false, &InstantiationDependent);
+        // The potential failure case here is this:
+        //
+        // template<typename U>
+        // concept C = true;
+        //
+        // template<typename T>
+        // void foo() requires C<T, T> // The immediate constraint expr
+        //                             // contains a CSE with incorrect no.
+        //                             // of arguments.
+        // {}
+        // This will be handled when C<T, T> is parsed.
+        assert(
+            !Failed &&
+            "Unmatched arguments in top level concept specialization "
+            "expression should've been caught while it was being constructed");
+
+        if (InstantiationDependent)
+          // The case is this:
+          //
+          // template<typename U, typename T>
+          // concept C = true;
+          //
+          // template<typename... Ts>
+          // void foo() requires C<Ts...> // The immediate constraint expr
+          //                              // contains a CSE whose parameters
+          //                              // are not mappable to arguments
+          //                              // without concrete values.
+          // {}
+          //
+          // Just treat C<Ts...> as an atomic constraint.
+          return NormalizedConstraint{new (S.Context)
+                                          AtomicConstraint(E, Mapping)};
+
+        return fromConstraintExpr(S,
+                                  CSE->getNamedConcept()->getConstraintExpr(),
+                                  CSE->getNamedConcept(), Mapping);
+      }
+
+      assert(TD && "ParameterMapping provided without TemplateDecl");
+
+      TemplateArgumentListInfo TALI(ParameterMapping->LAngleLoc,
+                                    ParameterMapping->RAngleLoc);
+      for (auto &Arg : ParameterMapping->arguments())
+        TALI.addArgument(Arg);
+      llvm::SmallVector<TemplateArgument, 4> TempList;
+      bool InstantiationDependent = false;
+      bool Success =
+          !S.CheckTemplateArgumentList(TD, ParameterMapping->LAngleLoc,
+                                       TALI, /*PartialTemplateArgs=*/false,
+                                       TempList,
+                                       /*UpdateArgsWithConversions=*/true,
+                                       &InstantiationDependent) &&
+          !InstantiationDependent;
+      assert(Success && "ParameterMapping should have already been cheked "
+                        "against template argument list earlier.");
+
+      auto DiagnoseSubstitutionError = [&](unsigned int Diag) {
+        std::string TemplateArgString = S.getTemplateArgumentBindingsText(
+            TD->getTemplateParameters(), TempList.data(), TempList.size());
+        S.Diag(CSE->getLocStart(), Diag) << CSE << TemplateArgString;
+      };
+
+      MultiLevelTemplateArgumentList MLTAL;
+      MLTAL.addOuterTemplateArguments(TempList);
+
+      ExprResult Result = S.SubstExpr(CSE, MLTAL);
+      if (!Result.isUsable() || Result.isInvalid()) {
+        // C++ [temp.constr.normal]
+        // If any such substitution results in an invalid type or
+        // expression, the program is ill-formed; no diagnostic is required.
+
+        // A diagnostic was already emitted from the substitution , but
+        // we'll let the user know why it's not SFINAEd from them.
+        DiagnoseSubstitutionError(
+            diag::note_could_not_normalize_argument_substitution_failed);
+        return llvm::Optional<NormalizedConstraint>{};
+      }
+      Mapping = cast<ConceptSpecializationExpr>(Result.get())
+                    ->getTemplateArgumentListInfo();
+
+      TemplateArgumentListInfo SubstTALI(ParameterMapping->LAngleLoc,
+                                         ParameterMapping->RAngleLoc);
+      for (auto &Arg : ParameterMapping->arguments())
+        SubstTALI.addArgument(Arg);
+      llvm::SmallVector<TemplateArgument, 4> Converted;
+      if (S.CheckTemplateArgumentList(
+              CSE->getNamedConcept(), CSE->getLocStart(), SubstTALI,
+              /*PartialTemplateArgs=*/false, Converted,
+              /*UpdateArgsWithConversions=*/true, &InstantiationDependent)) {
+        // The case is this:
+        //
+        // template<typename T, typename U>
+        // concept C1 = true;
+        //
+        // template<typename... Ts>
+        // concept C2 = C1<Ts...>; // After substituting Ts = {T}, the
+        //                         // resulting argument list does not match
+        //                         // the parameter list.
+        //
+        // template<typename T>
+        // void foo() requires C2<T> {}
+        DiagnoseSubstitutionError(
+            diag::note_could_not_normalize_unmatched_argument_list_after_subst);
+        return llvm::Optional<NormalizedConstraint>{};
+      }
+      if (InstantiationDependent)
+        // The case is this:
+        //
+        // template<typename T, typename U>
+        // concept C1 = true;
+        //
+        // template<typename... Us>
+        // concept C2 = C1<Us...>; // After substituting Us = {Ts}, we cannot
+        //                         // match arguments to parameters.
+        //
+        // template<typename... Ts>
+        // void foo() requires C2<T...> {}
+        //
+        // Treat the CSE as an atomic expression.
+        return NormalizedConstraint{new (S.Context)
+                                        AtomicConstraint(E, ParameterMapping)};
+
+      return fromConstraintExpr(S, CSE->getNamedConcept()->getConstraintExpr(),
+                                CSE->getNamedConcept(), Mapping);
+    }
+    return NormalizedConstraint{new (S.Context)
+                                    AtomicConstraint(E, ParameterMapping)};
+  }
+};
+} // namespace
+
+using NormalForm =
+    llvm::SmallVector<llvm::SmallVector<AtomicConstraint *, 2>, 4>;
+
+static NormalForm makeCNF(const NormalizedConstraint &Normalized) {
+  if (Normalized.isAtomic())
+    return {{Normalized.getAtomicConstraint()}};
+
+  NormalForm LCNF = makeCNF(Normalized.getLHS());
+  NormalForm RCNF = makeCNF(Normalized.getRHS());
+  if (Normalized.getCompoundKind() == NormalizedConstraint::CCK_Conjunction) {
+    LCNF.reserve(LCNF.size() + RCNF.size());
+    while (!RCNF.empty())
+      LCNF.push_back(std::move(RCNF.pop_back_val()));
+    return LCNF;
+  }
+
+  // Disjunction
+  NormalForm Res;
+  Res.reserve(LCNF.size() * RCNF.size());
+  for (auto &LDisjunction : LCNF)
+    for (auto &RDisjunction : RCNF) {
+      NormalForm::value_type Combined;
+      Combined.reserve(LDisjunction.size() + RDisjunction.size());
+      std::copy(LDisjunction.begin(), LDisjunction.end(),
+                std::back_inserter(Combined));
+      std::copy(RDisjunction.begin(), RDisjunction.end(),
+                std::back_inserter(Combined));
+      Res.emplace_back(Combined);
+    }
+  return Res;
+}
+
+static NormalForm makeDNF(const NormalizedConstraint &Normalized) {
+  if (Normalized.isAtomic())
+    return {{Normalized.getAtomicConstraint()}};
+
+  NormalForm LDNF = makeDNF(Normalized.getLHS());
+  NormalForm RDNF = makeDNF(Normalized.getRHS());
+  if (Normalized.getCompoundKind() == NormalizedConstraint::CCK_Disjunction) {
+    LDNF.reserve(LDNF.size() + RDNF.size());
+    while (!RDNF.empty())
+      LDNF.push_back(std::move(RDNF.pop_back_val()));
+    return LDNF;
+  }
+
+  // Conjunction
+  NormalForm Res;
+  Res.reserve(LDNF.size() * RDNF.size());
+  for (auto &LConjunction : LDNF) {
+    for (auto &RConjunction : RDNF) {
+      NormalForm::value_type Combined;
+      Combined.reserve(LConjunction.size() + RConjunction.size());
+      std::copy(LConjunction.begin(), LConjunction.end(),
+                std::back_inserter(Combined));
+      std::copy(RConjunction.begin(), RConjunction.end(),
+                std::back_inserter(Combined));
+      Res.emplace_back(Combined);
+    }
+  }
+  return Res;
+}
+
+static bool subsumes(Sema &S, Expr *P, Expr *Q) {
+  // C++ [temp.constr.order] p2
+  //   In order to determine if a constraint P subsumes a constraint Q, P is
+  //   transformed into disjunctive normal form, and Q is transformed into
+  //   conjunctive normal form. [...]
+  auto PNormalized = NormalizedConstraint::fromConstraintExpr(S, P);
+  if (!PNormalized)
+    // Program is ill formed at this point.
+    return false;
+  const NormalForm PDNF = makeDNF(*PNormalized);
+
+  auto QNormalized = NormalizedConstraint::fromConstraintExpr(S, Q);
+  if (!QNormalized)
+    // Program is ill formed at this point.
+    return false;
+  const NormalForm QCNF = makeCNF(*QNormalized);
+
+  // C++ [temp.constr.order] p2
+  //   Then, P subsumes Q if and only if, for every disjunctive clause Pi in the
+  //   disjunctive normal form of P, Pi subsumes every conjunctive clause Qj in
+  //   the conjuctive normal form of Q, where [...]
+  for (const auto &Pi : PDNF) {
+    for (const auto &Qj : QCNF) {
+      // C++ [temp.constr.order] p2
+      //   - [...] a disjunctive clause Pi subsumes a conjunctive clause Qj if
+      //     and only if there exists an atomic constraint Pia in Pi for which
+      //     there exists an atomic constraint, Qjb, in Qj such that Pia
+      //     subsumes Qjb.
+      bool Found = false;
+      for (const AtomicConstraint *Pia : Pi) {
+        for (const AtomicConstraint *Qjb : Qj) {
+          if (Pia->subsumes(S.Context, *Qjb)) {
+            Found = true;
+            break;
+          }
+        }
+        if (Found)
+          break;
+      }
+      if (!Found) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool Sema::IsMoreConstrained(NamedDecl *D1, Expr *AC1, NamedDecl *D2,
+                             Expr *AC2) {
+  if (!AC1)
+    return AC2 == nullptr;
+  if (!AC2)
+    // TD1 has associated constraints and TD2 does not.
+    return true;
+
+  std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
+  auto CacheEntry = SubsumptionCache.find(Key);
+  if (CacheEntry != SubsumptionCache.end()) {
+    return CacheEntry->second;
+  }
+  bool Subsumes = subsumes(*this, AC1, AC2);
+  SubsumptionCache.try_emplace(Key, Subsumes);
+  return Subsumes;
 }
 No newline at end of file

lib/Sema/SemaTemplate.cpp

Decl *Sema::ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
                                           SourceLocation EqualLoc,
                                           Expr *Default) {
   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
 
   // Check that we have valid decl-specifiers specified.
   auto CheckValidDeclSpecifiers = [this, &D] {
     // C++ [temp.param]
     // p1 
-    //   template-parameter:
-    //     ...
-    //     parameter-declaration
+    //   template-parameter:
+    //     ...
+    //     parameter-declaration
     // p2 
     //   ... A storage class shall not be specified in a template-parameter
     //   declaration.
     // [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) {
bool Sema::CheckTemplateParameterList(TemplateParameterList *NewParams,
   if (OldParams)
     OldParam = OldParams->begin();
 
   // TODO: Concepts: Replace getRequiresClause with getAssociatedConstraints
   // when we have it.
   if (OldParams &&
       !CheckRedeclarationConstraintMatch(OldParams->getRequiresClause(),
                                          NewParams->getRequiresClause())) {
-    Diag(NewParams->getTemplateLoc(),
-         diag::err_template_different_associated_constraints);
-    Diag(OldParams->getTemplateLoc(),  diag::note_template_prev_declaration)
-        << /*declaration*/0;
-
+    DiagnoseRedeclarationConstraintMismatch(OldParams, NewParams);
     Invalid = true;
   }
 
   bool RemoveDefaultArguments = false;
   for (TemplateParameterList::iterator NewParam = NewParams->begin(),
                                     NewParamEnd = NewParams->end();
        NewParam != NewParamEnd; ++NewParam) {
     // Variables used to diagnose redundant default arguments
if (!Name.isDependent() &&
             TemplateArgs.arguments(),
             InstantiationDependent)) {
       Diag(TemplateNameLoc, diag::err_partial_spec_fully_specialized)
           << VarTemplate->getDeclName();
       IsPartialSpecialization = false;
     }
 
     if (isSameAsPrimaryTemplate(VarTemplate->getTemplateParameters(),
-                                Converted)) {
+                                Converted)
+        && (!Context.getLangOpts().ConceptsTS
+            // TODO: Concepts: change this to getAssociatedConstraints when we
+            // have them.
+            || TemplateParams->getRequiresClause() == nullptr)) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
       //      to the implicit argument list of the primary template.
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)
         << /*variable template*/ 1
         << /*is definition*/(SC != SC_Extern && !CurContext->isRecord())
         << FixItHint::CreateRemoval(SourceRange(LAngleLoc, RAngleLoc));
       // FIXME: Recover from this by treating the declaration as a redeclaration
       // of the primary template.
       return true;
     }
   }
 
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *PrevDecl = nullptr;
 
   if (IsPartialSpecialization)
     // FIXME: Template parameter list matters too
-    PrevDecl = VarTemplate->findPartialSpecialization(Converted, InsertPos);
+    PrevDecl = VarTemplate->findPartialSpecialization(Converted,
+                                            // TODO: Concepts - replace with
+                                            // AssociatedConstraints once we
+                                            // have them.
+                                            TemplateParams->getRequiresClause(),
+                                                      InsertPos);
   else
     PrevDecl = VarTemplate->findSpecialization(Converted, InsertPos);
 
   VarTemplateSpecializationDecl *Specialization = nullptr;
 
   // Check whether we can declare a variable template specialization in
   // the current scope.
   if (CheckTemplateSpecializationScope(*this, VarTemplate, PrevDecl,
Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
                              const DeclarationNameInfo &NameInfo,
                              ConceptDecl *Template,
                              SourceLocation TemplateLoc,
                              const TemplateArgumentListInfo *TemplateArgs) {
   assert(Template && "A concept template id without template?");
 
   // Check that the template argument list is well-formed for this template.
   SmallVector<TemplateArgument, 4> Converted;
-  if (CheckTemplateArgumentList(Template, TemplateLoc,
+  if (CheckTemplateArgumentList(Template, NameInfo.getLoc(),
         const_cast<TemplateArgumentListInfo &>(*TemplateArgs), false,
           Converted, /*UpdateArgsWithConversions=*/false))
     return ExprError();
 
   return CreateConceptSpecializationExpr(NameInfo.getLoc(), Template,
                                          TemplateArgs);
 }
 
Sema::BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
   return E;
 }
 
 /// \brief Match two template parameters within template parameter lists.
 static bool MatchTemplateParameterKind(Sema &S, NamedDecl *New, NamedDecl *Old,
                                        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) {
       unsigned NextDiag = diag::err_template_param_different_kind;
       if (TemplateArgLoc.isValid()) {
         S.Diag(TemplateArgLoc, diag::err_template_arg_template_params_mismatch);
         NextDiag = diag::note_template_param_different_kind;
       }
Sema::TemplateParameterListsAreEqual(TemplateParameterList *New,
   if (NewParm != NewParmEnd) {
     if (Complain)
       DiagnoseTemplateParameterListArityMismatch(*this, New, Old, Kind,
                                                  TemplateArgLoc);
 
     return false;
   }
 
+  if (!CheckRedeclarationConstraintMatch(Old->getRequiresClause(),
+                                         New->getRequiresClause())) {
+    if (Complain)
+      DiagnoseRedeclarationConstraintMismatch(Old, New);
+    return false;
+  }
+
   return true;
 }
 
 /// \brief Check whether a template can be declared within this scope.
 ///
 /// If the template declaration is valid in this scope, returns
 /// false. Otherwise, issues a diagnostic and returns true.
 bool
if (isPartialSpecialization) {
     }
   }
 
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
 
   if (isPartialSpecialization)
     // FIXME: Template parameter list matters, too
-    PrevDecl = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
+    PrevDecl = ClassTemplate->findPartialSpecialization(Converted,
+                                            // TODO: Concepts: Replace with
+                                            // AssociatedConstraints once we
+                                            // have them.
+                                            TemplateParams->getRequiresClause(),
+                                                        InsertPos);
   else
     PrevDecl = ClassTemplate->findSpecialization(Converted, InsertPos);
 
   ClassTemplateSpecializationDecl *Specialization = nullptr;
 
   // Check whether we can declare a class template specialization in
   // the current scope.
   if (TUK != TUK_Friend &&
       CheckTemplateSpecializationScope(*this, ClassTemplate, PrevDecl,
                                        TemplateNameLoc,
                                        isPartialSpecialization))
     return true;
 
   // The canonical type
   QualType CanonType;
   if (isPartialSpecialization) {
     // Build the canonical type that describes the converted template
     // arguments of the class template partial specialization.
     TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
     CanonType = Context.getTemplateSpecializationType(CanonTemplate,
                                                       Converted);
 
     if (Context.hasSameType(CanonType,
-                        ClassTemplate->getInjectedClassNameSpecialization())) {
+                        ClassTemplate->getInjectedClassNameSpecialization())
+        && (!Context.getLangOpts().ConceptsTS
+            // TODO: Concepts: change this to getAssociatedConstraints when we
+            // have them.
+            || TemplateParams->getRequiresClause() == nullptr)) {
       // C++ [temp.class.spec]p9b3:
       //
       //   -- The argument list of the specialization shall not be identical
       //      to the implicit argument list of the primary template.
       //
       // This rule has since been removed, because it's redundant given DR1495,
       // but we keep it because it produces better diagnostics and recovery.
       Diag(TemplateNameLoc, diag::err_partial_spec_args_match_primary_template)

lib/Sema/SemaTemplateDeduction.cpp

 struct IsPartialSpecialization<ClassTemplatePartialSpecializationDecl> {
   static constexpr bool value = true;
 };
 template<>
 struct IsPartialSpecialization<VarTemplatePartialSpecializationDecl> {
   static constexpr bool value = true;
 };
 
+template<typename TemplateDeclT>
+static Sema::TemplateDeductionResult
+CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
+                                ArrayRef<TemplateArgument> DeducedArgs,
+                                TemplateDeductionInfo& Info) {
+  if (S.CheckConstraintSatisfaction(Template,
+                                    Template->getAssociatedConstraints(),
+                                    DeducedArgs, Info.getLocation(),
+                                    Info.AssociatedConstraintsSatisfaction)
+      || !Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
+    Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
+    return Sema::TDK_ConstraintsNotSatisfied;
+  }
+  return Sema::TDK_Success;
+}
+
 /// Complete template argument deduction for a partial specialization.
 template <typename T>
 static typename std::enable_if<IsPartialSpecialization<T>::value,
                                Sema::TemplateDeductionResult>::type
 FinishTemplateArgumentDeduction(
     Sema &S, T *Partial, bool IsPartialOrdering,
     const TemplateArgumentList &TemplateArgs,
     SmallVectorImpl<DeducedTemplateArgument> &Deduced,
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
       Info.SecondArg = InstArg;
       return Sema::TDK_NonDeducedMismatch;
     }
   }
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
+  if (auto Result = CheckDeducedArgumentConstraints(S, Partial, Builder, Info))
+    return Result;
+
   return Sema::TDK_Success;
 }
 
 /// Complete template argument deduction for a class or variable template,
 /// when partial ordering against a partial specialization.
 // FIXME: Factor out duplication with partial specialization version above.
 static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
     Sema &S, TemplateDecl *Template, bool PartialOrdering,
if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg,
       Info.SecondArg = InstArg;
       return Sema::TDK_NonDeducedMismatch;
     }
   }
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
-  return Sema::TDK_Success;
-}
+  if (auto Result = CheckDeducedArgumentConstraints(S, Template, Builder,
+                                                    Info))
+    return Result;
 
-template<typename TemplateDeclT>
-static Sema::TemplateDeductionResult
-CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
-                                ArrayRef<TemplateArgument> DeducedArgs,
-                                TemplateDeductionInfo& Info) {
-  if (S.CheckConstraintSatisfaction(Template,
-                                    Template->getAssociatedConstraints(),
-                                    DeducedArgs, Info.getLocation(),
-                                    Info.AssociatedConstraintsSatisfaction)
-      || !Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
-    Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
-    return Sema::TDK_ConstraintsNotSatisfied;
-  }
   return Sema::TDK_Success;
 }
 
 /// \brief Perform template argument deduction to determine whether
 /// the given template arguments match the given class template
 /// partial specialization per C++ [temp.class.spec.match].
 Sema::TemplateDeductionResult
 Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
   InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
                              Info);
   if (Inst.isInvalid())
     return TDK_InstantiationDepth;
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
-  if (TemplateDeductionResult Result
-        = CheckDeducedArgumentConstraints(*this, Partial, DeducedArgs, Info))
-    return Result;
-
   return ::FinishTemplateArgumentDeduction(
       *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info);
 }
 
 /// \brief Perform template argument deduction to determine whether
 /// the given template arguments match the given variable template
 /// partial specialization per C++ [temp.class.spec.match].
 Sema::TemplateDeductionResult
Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
   InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
                              Info);
   if (Inst.isInvalid())
     return TDK_InstantiationDepth;
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
-  if (TemplateDeductionResult Result
-        = CheckDeducedArgumentConstraints(*this, Partial, DeducedArgs, Info))
-    return Result;
-
   return ::FinishTemplateArgumentDeduction(
       *this, Partial, /*PartialOrdering=*/false, TemplateArgs, Deduced, Info);
 }
 
 /// \brief Determine whether the given type T is a simple-template-id type.
 static bool isSimpleTemplateIdType(QualType T) {
   if (const TemplateSpecializationType *Spec
         = T->getAs<TemplateSpecializationType>())
Sema::SubstituteExplicitTemplateArguments(
   }
 
   // Form the template argument list from the explicitly-specified
   // template arguments.
   TemplateArgumentList *ExplicitArgumentList
     = TemplateArgumentList::CreateCopy(Context, Builder);
   Info.reset(ExplicitArgumentList);
 
-  if (TemplateDeductionResult Result
-        = CheckDeducedArgumentConstraints(*this, FunctionTemplate,
-                                          ExplicitArgumentList->asArray(),
-                                          Info))
-    return Result;
-
   // Template argument deduction and the final substitution should be
   // done in the context of the templated declaration.  Explicit
   // argument substitution, on the other hand, needs to happen in the
   // calling context.
   ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
 
   // If we deduced template arguments for a template parameter pack,
   // note that the template argument pack is partially substituted and record
Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
   SmallVector<TemplateArgument, 4> Builder;
   if (auto Result = ConvertDeducedTemplateArguments(
           *this, FunctionTemplate, /*IsDeduced*/true, Deduced, Info, Builder,
           CurrentInstantiationScope, NumExplicitlySpecified,
           PartialOverloading))
     return Result;
 
   if (TemplateDeductionResult Result
-        = CheckDeducedArgumentConstraints(*this, FunctionTemplate, DeducedArgs,
+        = CheckDeducedArgumentConstraints(*this, FunctionTemplate, Builder,
                                           Info))
     return Result;
 
   // C++ [temp.deduct.call]p10: [DR1391]
   //   If deduction succeeds for all parameters that contain
   //   template-parameters that participate in template argument deduction,
   //   and all template arguments are explicitly specified, deduced, or
   //   obtained from default template arguments, remaining parameters are then
for (; ArgIdx != NumArgs; ++ArgIdx)
     // If this argument had no value deduced but was used in one of the types
     // used for partial ordering, then deduction fails.
     if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
       return false;
 
   return true;
 }
 
+/// Determine whether one partial specialization, P1, is at least as
+/// specialized than another, P2, based on deduction checking.
+///
+/// \tparam TemplateLikeDecl The kind of P2, which must be a TemplateDecl or
+/// {Class,Var}TemplatePartialSpecializationDecl.
+/// \param T1 The injected-class-name of P1 (faked for a variable template).
+/// \param T2 The injected-class-name of P2 (faked for a variable template).
+template<typename TemplateLikeDecl>
+static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
+                                     TemplateLikeDecl *P2,
+                                     TemplateDeductionInfo &Info) {
+    // C++ [temp.class.order]p1:
+    //   For two class template partial specializations, the first is at least as
+    //   specialized as the second if, given the following rewrite to two
+    //   function templates, the first function template is at least as
+    //   specialized as the second according to the ordering rules for function
+    //   templates (14.6.6.2):
+    //     - the first function template has the same template parameters as the
+    //       first partial specialization and has a single function parameter
+    //       whose type is a class template specialization with the template
+    //       arguments of the first partial specialization, and
+    //     - the second function template has the same template parameters as the
+    //       second partial specialization and has a single function parameter
+    //       whose type is a class template specialization with the template
+    //       arguments of the second partial specialization.
+    //
+    // Rather than synthesize function templates, we merely perform the
+    // equivalent partial ordering by performing deduction directly on
+    // the template arguments of the class template partial
+    // specializations. This computation is slightly simpler than the
+    // general problem of function template partial ordering, because
+    // class template partial specializations are more constrained. We
+    // know that every template parameter is deducible from the class
+    // template partial specialization's template arguments, for
+    // example.
+    SmallVector<DeducedTemplateArgument, 4> Deduced;
+
+    // Determine whether P1 is at least as specialized as P2.
+    Deduced.resize(P2->getTemplateParameters()->size());
+    if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(),
+                                           T2, T1, Info, Deduced, TDF_None,
+            /*PartialOrdering=*/true))
+        return false;
+
+    SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+                                                 Deduced.end());
+    Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs,
+                                     Info);
+    auto *TST1 = T1->castAs<TemplateSpecializationType>();
+    if (FinishTemplateArgumentDeduction(
+            S, P2, /*PartialOrdering=*/true,
+            TemplateArgumentList(TemplateArgumentList::OnStack,
+                                 TST1->template_arguments()),
+            Deduced, Info))
+        return false;
+
+    return true;
+}
+
 /// \brief Determine whether this a function template whose parameter-type-list
 /// ends with a function parameter pack.
 static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) {
   FunctionDecl *Function = FunTmpl->getTemplatedDecl();
   unsigned NumParams = Function->getNumParams();
   if (NumParams == 0)
     return false;
 

 /// template is more specialized, returns NULL.
 FunctionTemplateDecl *
 Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
                                  FunctionTemplateDecl *FT2,
                                  SourceLocation Loc,
                                  TemplatePartialOrderingContext TPOC,
                                  unsigned NumCallArguments1,
                                  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)
+      return nullptr;
+    return MoreConstrained1 ? FT1 : FT2;
+  };
+
   bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
                                           NumCallArguments1);
   bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
                                           NumCallArguments2);
 
   if (Better1 != Better2) // We have a clear winner
     return Better1 ? FT1 : FT2;
 
   if (!Better1 && !Better2) // Neither is better than the other
-    return nullptr;
+    return JudgeByConstraints();
 
   // FIXME: This mimics what GCC implements, but doesn't match up with the
   // proposed resolution for core issue 692. This area needs to be sorted out,
   // but for now we attempt to maintain compatibility.
   bool Variadic1 = isVariadicFunctionTemplate(FT1);
   bool Variadic2 = isVariadicFunctionTemplate(FT2);
   if (Variadic1 != Variadic2)
     return Variadic1? FT2 : FT1;
 
-  return nullptr;
+  return JudgeByConstraints();
 }
 
 /// \brief Determine if the two templates are equivalent.
 static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
   if (T1 == T2)
     return true;
 
   if (!T1 || !T2)
for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
         HandleFunctionTypeMismatch(PD, FD->getType(), TargetType);
       Diag((*I)->getLocation(), PD);
     }
   }
 
   return SpecEnd;
 }
 
-/// Determine whether one partial specialization, P1, is at least as
-/// specialized than another, P2.
-///
-/// \tparam TemplateLikeDecl The kind of P2, which must be a
-/// TemplateDecl or {Class,Var}TemplatePartialSpecializationDecl.
-/// \param T1 The injected-class-name of P1 (faked for a variable template).
-/// \param T2 The injected-class-name of P2 (faked for a variable template).
-template<typename TemplateLikeDecl>
-static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
-                                     TemplateLikeDecl *P2,
-                                     TemplateDeductionInfo &Info) {
-  // TODO: Concepts: Regard constraints
-  // C++ [temp.class.order]p1:
-  //   For two class template partial specializations, the first is at least as
-  //   specialized as the second if, given the following rewrite to two
-  //   function templates, the first function template is at least as
-  //   specialized as the second according to the ordering rules for function
-  //   templates (14.6.6.2):
-  //     - the first function template has the same template parameters as the
-  //       first partial specialization and has a single function parameter
-  //       whose type is a class template specialization with the template
-  //       arguments of the first partial specialization, and
-  //     - the second function template has the same template parameters as the
-  //       second partial specialization and has a single function parameter
-  //       whose type is a class template specialization with the template
-  //       arguments of the second partial specialization.
-  //
-  // Rather than synthesize function templates, we merely perform the
-  // equivalent partial ordering by performing deduction directly on
-  // the template arguments of the class template partial
-  // specializations. This computation is slightly simpler than the
-  // general problem of function template partial ordering, because
-  // class template partial specializations are more constrained. We
-  // know that every template parameter is deducible from the class
-  // template partial specialization's template arguments, for
-  // example.
-  SmallVector<DeducedTemplateArgument, 4> Deduced;
-
-  // Determine whether P1 is at least as specialized as P2.
-  Deduced.resize(P2->getTemplateParameters()->size());
-  if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(),
-                                         T2, T1, Info, Deduced, TDF_None,
-                                         /*PartialOrdering=*/true))
-    return false;
-
-  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
-                                               Deduced.end());
-  Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs,
-                                   Info);
-  auto *TST1 = T1->castAs<TemplateSpecializationType>();
-  if (FinishTemplateArgumentDeduction(
-          S, P2, /*PartialOrdering=*/true,
-          TemplateArgumentList(TemplateArgumentList::OnStack,
-                               TST1->template_arguments()),
-          Deduced, Info))
-    return false;
-
-  return true;
-}
-
 /// \brief Returns the more specialized class template partial specialization
 /// according to the rules of partial ordering of class template partial
 /// specializations (C++ [temp.class.order]).
 ///
 /// \param PS1 the first class template partial specialization
 ///
 /// \param PS2 the second class template partial specialization
 ///
 /// \returns the more specialized class template partial specialization. If
 /// neither partial specialization is more specialized, returns NULL.
 ClassTemplatePartialSpecializationDecl *
 Sema::getMoreSpecializedPartialSpecialization(
                                   ClassTemplatePartialSpecializationDecl *PS1,
                                   ClassTemplatePartialSpecializationDecl *PS2,
                                               SourceLocation Loc) {
   QualType PT1 = PS1->getInjectedSpecializationType();
   QualType PT2 = PS2->getInjectedSpecializationType();
 
   TemplateDeductionInfo Info(Loc);
   bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
   bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
 
-  if (Better1 == Better2)
+  if (Better1 == Better2) {
+    bool MoreConstrained1 = IsMoreConstrained(PS1,
+                                              PS1->getAssociatedConstraints(),
+                                              PS2,
+                                              PS2->getAssociatedConstraints());
+    bool MoreConstrained2 = IsMoreConstrained(PS2,
+                                              PS2->getAssociatedConstraints(),
+                                              PS1,
+                                              PS1->getAssociatedConstraints());
+    if (MoreConstrained1 == MoreConstrained2)
       return nullptr;
+    return MoreConstrained1 ? PS1 : PS2;
+  }
 
   return Better1 ? PS1 : PS2;
 }
 
 bool Sema::isMoreSpecializedThanPrimary(
     ClassTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
   ClassTemplateDecl *Primary = Spec->getSpecializedTemplate();
   QualType PrimaryT = Primary->getInjectedClassNameSpecialization();
   QualType PartialT = Spec->getInjectedSpecializationType();
-  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
+  auto JudgeByConstraints = [&] {
+    bool MoreConstrainedPrimary = IsMoreConstrained(Primary,
+                                            Primary->getAssociatedConstraints(),
+                                            Spec,
+                                            Spec->getAssociatedConstraints());
+    bool MoreConstrainedSpec = IsMoreConstrained(Spec,
+                                           Spec->getAssociatedConstraints(),
+                                           Primary,
+                                           Primary->getAssociatedConstraints());
+    if (MoreConstrainedPrimary == MoreConstrainedSpec)
       return false;
-  if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) {
+    return MoreConstrainedSpec;
+  };
+  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
+    return JudgeByConstraints();
+  if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)){
     Info.clearSFINAEDiagnostic();
-    return false;
+    return JudgeByConstraints();
   }
   return true;
 }
 
 VarTemplatePartialSpecializationDecl *
 Sema::getMoreSpecializedPartialSpecialization(
     VarTemplatePartialSpecializationDecl *PS1,
     VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
   // Pretend the variable template specializations are class template
   // specializations and form a fake injected class name type for comparison.
   assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
          "the partial specializations being compared should specialize"
          " the same template.");
   TemplateName Name(PS1->getSpecializedTemplate());
   TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
   QualType PT1 = Context.getTemplateSpecializationType(
       CanonTemplate, PS1->getTemplateArgs().asArray());
   QualType PT2 = Context.getTemplateSpecializationType(
       CanonTemplate, PS2->getTemplateArgs().asArray());
 
   TemplateDeductionInfo Info(Loc);
   bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
   bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
 
-  if (Better1 == Better2)
+  if (Better1 == Better2) {
+    bool MoreConstrained1 = IsMoreConstrained(PS1,
+                                              PS1->getAssociatedConstraints(),
+                                              PS2,
+                                              PS2->getAssociatedConstraints());
+    bool MoreConstrained2 = IsMoreConstrained(PS2,
+                                              PS2->getAssociatedConstraints(),
+                                              PS1,
+                                              PS1->getAssociatedConstraints());
+    if (MoreConstrained1 == MoreConstrained2) {
       return nullptr;
+    }
+    return MoreConstrained1 ? PS1 : PS2;
+  }
 
   return Better1 ? PS1 : PS2;
 }
 
 bool Sema::isMoreSpecializedThanPrimary(
     VarTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
   TemplateDecl *Primary = Spec->getSpecializedTemplate();
   // FIXME: Cache the injected template arguments rather than recomputing
   // them for each partial specialization.
   SmallVector<TemplateArgument, 8> PrimaryArgs;
   Context.getInjectedTemplateArgs(Primary->getTemplateParameters(),
                                   PrimaryArgs);
 
   TemplateName CanonTemplate =
       Context.getCanonicalTemplateName(TemplateName(Primary));
   QualType PrimaryT = Context.getTemplateSpecializationType(
       CanonTemplate, PrimaryArgs);
   QualType PartialT = Context.getTemplateSpecializationType(
       CanonTemplate, Spec->getTemplateArgs().asArray());
-  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
+
+  auto JudgeByConstraints = [&] {
+      bool MoreConstrainedPrimary = IsMoreConstrained(Primary,
+                                            Primary->getAssociatedConstraints(),
+                                            Spec,
+                                            Spec->getAssociatedConstraints());
+      bool MoreConstrainedSpec = IsMoreConstrained(Spec,
+                                           Spec->getAssociatedConstraints(),
+                                           Primary,
+                                           Primary->getAssociatedConstraints());
+      if (MoreConstrainedPrimary == MoreConstrainedSpec)
         return false;
-  if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)) {
+      return MoreConstrainedSpec;
+  };
+
+  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
+    return JudgeByConstraints();
+  if (isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info)){
     Info.clearSFINAEDiagnostic();
-    return false;
+    return JudgeByConstraints();
   }
   return true;
 }
 
 bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
      TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc) {
   // C++1z [temp.arg.template]p4: (DR 150)
   //   A template template-parameter P is at least as specialized as a

lib/Sema/SemaTemplateInstantiateDecl.cpp

if (SemaRef.CheckTemplatePartialSpecializationArgs(
           PartialSpec->getLocation(), ClassTemplate, InstTemplateArgs.size(),
           Converted))
     return nullptr;
 
   // Figure out where to insert this class template partial specialization
   // in the member template's set of class template partial specializations.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl
-    = ClassTemplate->findPartialSpecialization(Converted, InsertPos);
+    = ClassTemplate->findPartialSpecialization(Converted,
+                                               // TODO: Concepts - change this
+                                               // to associated constraints once
+                                               // we have them.
+                                               InstParams->getRequiresClause(),
+                                               InsertPos);
 
   // Build the canonical type that describes the converted template
   // arguments of the class template partial specialization.
   QualType CanonType
     = SemaRef.Context.getTemplateSpecializationType(TemplateName(ClassTemplate),
                                                     Converted);
 
   // Build the fully-sugared type for this class template
if (SemaRef.CheckTemplatePartialSpecializationArgs(
           PartialSpec->getLocation(), VarTemplate, InstTemplateArgs.size(),
           Converted))
     return nullptr;
 
   // Figure out where to insert this variable template partial specialization
   // in the member template's set of variable template partial specializations.
   void *InsertPos = nullptr;
   VarTemplateSpecializationDecl *PrevDecl =
-      VarTemplate->findPartialSpecialization(Converted, InsertPos);
+      VarTemplate->findPartialSpecialization(Converted,
+                                             // TODO: Concepts - change this
+                                             // to associated constraints once
+                                             // we have them.
+                                             InstParams->getRequiresClause(),
+                                             InsertPos);
 
   // Build the canonical type that describes the converted template
   // arguments of the variable template partial specialization.
   QualType CanonType = SemaRef.Context.getTemplateSpecializationType(
       TemplateName(VarTemplate), Converted);
 
   // Build the fully-sugared type for this variable template
   // specialization as the user wrote in the specialization

lib/Serialization/ASTReaderDecl.cpp

if (TypeSourceInfo *TyInfo = GetTypeSourceInfo()) {
     D->ExplicitInfo = ExplicitInfo;
   }
 
   return Redecl;
 }
 
 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
                                     ClassTemplatePartialSpecializationDecl *D) {
-  RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
-
+  // We need to read the template params first because redeclarable is going to
+  // need them for profiling
   TemplateParameterList *Params = Record.readTemplateParameterList();
   D->TemplateParams.setPointer(Params);
   D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
 
+  RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
+
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(
       ReadDeclAs<ClassTemplatePartialSpecializationDecl>());
     D->InstantiatedFromMember.setInt(Record.readInt());
     bool HasAssociatedConstraints = Record.readInt();
     D->TemplateParams.setInt(true);
     if (HasAssociatedConstraints) {

 
 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
 ///        VarTemplate(Partial)SpecializationDecl with a new data
 ///        structure Template(Partial)SpecializationDecl, and
 ///        using Template(Partial)SpecializationDecl as input type.
 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
     VarTemplatePartialSpecializationDecl *D) {
-  RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
-
   TemplateParameterList *Params = Record.readTemplateParameterList();
   D->TemplateParams.setPointer(Params);
   D->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
 
+  RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
+
   // These are read/set from/to the first declaration.
   if (ThisDeclID == Redecl.getFirstID()) {
     D->InstantiatedFromMember.setPointer(
         ReadDeclAs<VarTemplatePartialSpecializationDecl>());
     D->InstantiatedFromMember.setInt(Record.readInt());
 
     bool HasAssociatedConstraints = Record.readInt();
     D->TemplateParams.setInt(true);

lib/Serialization/ASTWriterDecl.cpp

if (D->getTypeAsWritten()) {
     Record.AddSourceLocation(D->getTemplateKeywordLoc());
   }
 
   Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
                                     ClassTemplatePartialSpecializationDecl *D) {
-  VisitClassTemplateSpecializationDecl(D);
-
   Record.AddTemplateParameterList(D->getTemplateParameters());
   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
 
+  VisitClassTemplateSpecializationDecl(D);
+
   // These are read/set from/to the first declaration.
   if (D->getPreviousDecl() == nullptr) {
     Record.AddDeclRef(D->getInstantiatedFromMember());
     Record.push_back(D->isMemberSpecialization());
     Expr *AssociatedConstraints = D->getAssociatedConstraints();
     Record.push_back(AssociatedConstraints != nullptr);
     if (AssociatedConstraints) {
       Record.AddStmt(AssociatedConstraints);
if (D->isCanonicalDecl()) {
     Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
   }
 
   Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
     VarTemplatePartialSpecializationDecl *D) {
-  VisitVarTemplateSpecializationDecl(D);
-
   Record.AddTemplateParameterList(D->getTemplateParameters());
   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
 
+  VisitVarTemplateSpecializationDecl(D);
+
   // These are read/set from/to the first declaration.
   if (D->getPreviousDecl() == nullptr) {
     Record.AddDeclRef(D->getInstantiatedFromMember());
     Record.push_back(D->isMemberSpecialization());
     Expr *AssociatedConstraints = D->getAssociatedConstraints();
     Record.push_back(AssociatedConstraints != nullptr);
     if (AssociatedConstraints) {
       Record.AddStmt(AssociatedConstraints);

test/CXX/concepts-ts/temp/temp.constr/temp.constr.decl/func-template-decl.cpp

 // RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
 
 namespace nodiag {
 
 template <typename T> requires bool(T())
 int A();
 template <typename U> requires bool(U())
 int A();
 
 } // end namespace nodiag
 
-namespace diag {
-
-template <typename T> requires true // expected-note{{previous template declaration is here}}
-int A();
-template <typename T> int A(); // expected-error{{associated constraints differ in template redeclaration}}
-
-template <typename T> int B(); // expected-note{{previous template declaration is here}}
-template <typename T> requires true // expected-error{{associated constraints differ in template redeclaration}}
-int B();
-
-template <typename T> requires true // expected-note{{previous template declaration is here}}
-int C();
-template <typename T> requires !0 // expected-error{{associated constraints differ in template redeclaration}}
-int C();
-
-} // end namespace diag
-
 namespace nodiag {
 
 struct AA {
   template <typename T> requires someFunc(T())
   int A();
 };
 
 template <typename T> requires someFunc(T())
 int AA::A() { return sizeof(T); }
 
 } // end namespace nodiag
 
 namespace diag {
 
 template <unsigned N>
 struct TA {
-  template <template <unsigned> class TT> requires TT<N>::happy // expected-note{{previous template declaration is here}}
+  template <template <unsigned> class TT> requires TT<N>::happy
   int A();
 };
 
 template <unsigned N>
-template <template <unsigned> class TT> int TA<N>::A() { return sizeof(TT<N>); } // expected-error{{associated constraints differ in template redeclaration}}
+template <template <unsigned> class TT> int TA<N>::A() { return sizeof(TT<N>); } // expected-error{{out-of-line definition of 'A' does not match any declaration in 'TA<N>'}}
 
 } // end namespace diag

test/CXX/concepts-ts/temp/temp.constr/temp.constr.normal/p1.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+namespace maybe_incorrect_args {
+  template<typename U, typename T>
+  concept C = true;
+
+  // diagnostic expected here - the C<Ts...>s are treated as atomic, and since
+  // they originate from different source-level constructs, they do not subsume
+  // each other.
+  template<typename... Ts> requires C<Ts...>
+  struct A {}; // expected-note{{template is declared here}}
+
+  template<typename... Ts> requires C<Ts...> && true
+  struct A<Ts...> {}; // expected-error{{class template partial specialization is not more specialized than the primary template}}
+}
+
+namespace ill_formed_subst {
+
+  template<typename T>
+  struct B; // expected-note 2{{template is declared here}}
+
+  template<typename T>
+  concept C1 = true;
+
+  template<typename T, typename U>
+  concept C2 = C1<typename B<U>::foo>; // expected-error 2{{implicit instantiation of undefined template 'ill_formed_subst::B<int>'}} expected-note 2{{could not substitute template arguments into C1<typename B<U>::foo> [with T = type-parameter-0-0, U = int]. Template arguments to a concept specialization expression must be valid expressions}}
+
+  template<typename T> requires C2<T, int>
+  struct A {}; // expected-note {{template is declared here}}
+
+  template<typename T> requires C2<T, int> && true
+  struct A<T> {}; // expected-error {{class template partial specialization is not more specialized than the primary template}}
+}
+
+namespace incorrect_args_after_subst {
+  template<typename T>
+  concept C1 = true; // expected-note 2{{template is declared here}}
+
+  template<typename... Ts>
+  concept C2 = C1<Ts...>; // expected-error 2{{too many template arguments for template 'C1'}} expected-note 2{{could not substitute template arguments into C1<Ts...> [with Ts = <type-parameter-0-0, type-parameter-0-0>] - the resulting template argument list does not match the concept's parameter list}}
+
+  template<typename T> requires C2<T, T>
+  struct A {}; // expected-note{{template is declared here}}
+
+  template<typename T> requires C2<T, T> && true
+  struct A<T> {}; // expected-error{{class template partial specialization is not more specialized than the primary template}}
+}
+
+namespace maybe_incorrect_args_after_subst {
+  template<typename T, typename U>
+  concept C1 = true;
+
+  template<typename... Us>
+  concept C2 = C1<Us...>;
+
+  // no diagnostic expected here - C1<Us...> is treated as atomic, and since it
+  // originates at the same source level construct, the specialized subsumes the
+  // primary.
+  template<typename... Ts> requires C2<Ts...>
+  struct A {};
+
+  template<typename... Ts> requires C2<Ts...> && true
+  struct A<Ts...> {};
+}
 No newline at end of file

test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T> requires sizeof(T) >= 4
+class A{}; // expected-note{{template is declared here}}
+
+template<typename T> requires sizeof(T) >= 4 && sizeof(T) <= 10
+class A<T>{}; // expected-error{{class template partial specialization is not more specialized than the primary template}}
+
+template<typename T>
+concept C1 = sizeof(T) >= 4;
+
+template<typename T> requires C1<T>
+class B{};
+
+template<typename T> requires C1<T> && sizeof(T) <= 10
+class B<T>{};
+
+template<typename T>
+concept C2 = sizeof(T) > 1 && sizeof(T) <= 8;
+
+template<typename T>
+class C{};
+
+template<typename T> requires C1<T>
+class C<T>{};
+
+template<typename T>
+class D{}; // expected-note{{previous definition is here}}
+
+template<typename T>
+class D<T>{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}} expected-error{{redefinition of 'D'}}
+
+template<typename T> requires C1<T> // expected-note{{previous template declaration is here}}
+class E{};
+
+template<typename T> // expected-error{{associated constraints differ in template redeclaration}}
+class E<T>{}; // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
+
+template<typename T>
+struct F{ enum{ value = 1 }; };
+
+template<typename T> requires C1<T> && C2<T>
+struct F<T>{ enum{ value = 2 }; };
+
+template<typename T> requires C1<T> || C2<T>
+struct F<T>{ enum{ value = 3 }; };
+
+static_assert(F<unsigned>::value == 2);
+static_assert(F<char[10]>::value == 3);
+static_assert(F<char>::value == 1);
+
+template<typename T1, typename T2>
+concept C3 = true;
+
+template<typename... Ts>
+concept C4 = C3<Ts...>;
+
+// C4 is normalized to C3<Ts...>@<C4's definition> because there is a pack
+// expansion into a non-pack parameter. therefore the two C4<T...> subsume each
+// other and the following is non-ambiguous.
+
+template<typename... T> requires C4<T...>
+struct G { };
+
+template<typename... T> requires C4<T...> && C4<int, short>
+struct G<T...> { };
+
+// Here the two C3s cannot be normalized further, and do not subsume each other
+// because they originate in two different locations in code.
+
+template<typename... T> requires C3<T...>
+struct H { }; // expected-note {{template is declared here}}
+
+template<typename... T> requires C3<T...> && C4<int, short>
+struct H<T...> { }; // expected-error {{class template partial specialization is not more specialized than the primary template}}
+
+// Make sure atomic constraints subsume each other only if their parameter
+// mappings are identical.
+
+template<typename T, typename U> requires C2<T>
+struct I { }; // expected-note {{template is declared here}}
+
+template<typename T, typename U> requires C2<U>
+struct I<T, U> { }; // expected-error {{class template partial specialization is not more specialized than the primary template}}
 No newline at end of file

test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/function-templates.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T> requires sizeof(T) >= 4
+bool a() { return false; } // expected-note {{candidate function [with T = unsigned int]}}
+
+template<typename T> requires sizeof(T) >= 4 && sizeof(T) <= 10
+bool a() { return true; } // expected-note {{candidate function [with T = unsigned int]}}
+
+bool av = a<unsigned>(); // expected-error {{call to 'a' is ambiguous}}
+
+template<typename T>
+concept C1 = sizeof(T) >= 4;
+
+template<typename T> requires C1<T>
+constexpr bool b() { return false; }
+
+template<typename T> requires C1<T> && sizeof(T) <= 10
+constexpr bool b() { return true; }
+
+static_assert(b<int>());
+static_assert(!b<int[10]>());
+
+template<typename T>
+concept C2 = sizeof(T) > 1 && sizeof(T) <= 8;
+
+template<typename T>
+bool c() { return false; }
+
+template<typename T> requires C1<T>
+bool c() { return true; }
+
+template<typename T> requires C1<T>
+constexpr bool d() { return false; }
+
+template<typename T>
+constexpr bool d() { return true; }
+
+static_assert(!d<int>());
+
+template<typename T>
+constexpr int e() { return 1; }
+
+template<typename T> requires C1<T> && C2<T>
+constexpr int e() { return 2; }
+
+template<typename T> requires C1<T> || C2<T>
+constexpr int e() { return 3; }
+
+static_assert(e<unsigned>() == 2);
+static_assert(e<char[10]>() == 3);
+static_assert(e<char>() == 1);
+
+
+

test/CXX/concepts-ts/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T> requires sizeof(T) >= 4
+bool a = false; // expected-note{{template is declared here}}
+
+template<typename T> requires sizeof(T) >= 4 && sizeof(T) <= 10
+bool a<T> = true; // expected-error{{variable template partial specialization is not more specialized than the primary template}}
+
+template<typename T>
+concept C1 = sizeof(T) >= 4;
+
+template<typename T> requires C1<T>
+bool b = false;
+
+template<typename T> requires C1<T> && sizeof(T) <= 10
+bool b<T> = true;
+
+template<typename T>
+concept C2 = sizeof(T) > 1 && sizeof(T) <= 8;
+
+template<typename T>
+bool c = false;
+
+template<typename T> requires C1<T>
+bool c<T> = true;
+
+template<typename T>
+bool d = false;
+
+template<typename T>
+bool d<T> = true; // expected-error{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
+
+template<typename T> requires C1<T>
+bool e = false;
+
+template<typename T>
+bool e<T> = true; // expected-error{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
+
+template<typename T>
+constexpr int f = 1;
+
+template<typename T> requires C1<T> && C2<T>
+constexpr int f<T> = 2;
+
+template<typename T> requires C1<T> || C2<T>
+constexpr int f<T> = 3;
+
+static_assert(f<unsigned> == 2);
+static_assert(f<char[10]> == 3);
+static_assert(f<char> == 1);
+
+
+