[Concepts] Constraint enforcement and diagnostics

[saar.raz]

Summary

• Associated constraints (requires clauses, currently) are now enforced when instantiating/specializing templates and when considering partial specializations and function overloads.
• Elaborated diagnostics give helpful insight as to why the constraints were not satisfied.

This patch depends upon D41284

[saar.raz]

• Better handling of diagnostics in ConceptSpecializationExprs, correctly written to and read from module files.
• Modified Error messages according to some user feedback

Updating D41569: Summary:

Constraint enforcement and diagnostics

[saar.raz]

• When a conjunction constraint expression has both sides false, both sides will now be diagnosed.

Updating D41569: Summary:

Constraint enforcement and diagnostics

[saar.raz]

Fixed crash caused by substitution of pack expansion into non-pack parameters in constraint expressions.

Updating D41569: Summary:

Constraint enforcement and diagnostics

[saar.raz]

Adjusted to changes in D41217

[saar.raz]

Fixed SpecializedConcept reference to NamedConcept.

[saar.raz]

Fixed another SpecializedConcept reference to NamedConcept.

[saar.raz]

Adjusted to piecewise substitution.

• Constraint satisfaction will no longer happen for depenent CSEs (was originally needed for normalization, but not worth the trouble with the new piecewise substitution and the fact that it prevents short-circuting)
• Constraint satisfaction checking now breaks down unsatisfied constraint exprs into atomic constraints with the ill-formed diagnostic or the substituted constraint expression for each, later consumed by the diagnostic functions.

[saar.raz]

• Adjusted to switch to ASTTemplateArgumentList

[saar.raz]

• Adjusted to new CodeSynthesisContexts, added tests for them.

[saar.raz]

Rebase onto trunk, add static assert diagnostics

[saar.raz]

Adjusted to changes in getAssociatedConstraints interface

[saar.raz]

Fix incorrect handling of recovered-from errors in constraint substitutions.

[saar.raz]

Add support for CSE mangling

[saar.raz]

Create ASTConstraintSatisfaction for correctly storing constraint satisfaction data in AST nodes.

[saar.raz]

Rebase onto trunk.

[saar.raz]

Move ConstraintSatisfaction to ASTConcept.h

[rsmith]

lib/AST/ItaniumMangle.cpp

4127 ↗

(On Diff #209695)

These mangling changes look like they could be separated out from the rest of the patch. These plus the associated test look fine to check in as-is.

lib/Sema/SemaConcept.cpp

161 ↗

(On Diff #209695)

We should store the diagnostic as a PartialDiagnostic rather than as a string. (Currently that's a pain: we don't have serialization support for PartialDiagnostics, and they have a huge storage cost -- probably even larger than the fully-formatted string. But it's the right thing to do in the longer term. We want to expose the structured diagnostic to tools (such as IDEs) that want to present them in different ways, and if we ever support translation of diagnostics, we don't want the contents of module files to depend on the diagnostic language used when building the module file.)

Please add a FIXME for this.

lib/Sema/SemaDeclCXX.cpp

14032 ↗

(On Diff #209695)

Would it be reasonable and feasible to unify findFailedBooleanCondition and diagnoseWellFormedUnsatisfiedConstraintExpr? They seem to be doing quite similar things.

lib/Sema/SemaTemplate.cpp

7662–7664

Can we move this into CheckTemplateArgumentList? Would that make sense in the bigger picture?

(Please put the && on the previous line.)

lib/Sema/SemaTemplateDeduction.cpp

2665

Style nit: space before & not after

2671

Style nit: || on previous line

2722–2724

This should be done in (or maybe immediately after) ConvertDeducedTemplateArguments (called by FinishTemplateArgumentDeduction), rather than here: that way, we'll convert the deduced arguments to the right kind, and pick up (and substitute into) any default template arguments as necessary before checking constraint satisfaction. We probably typically get away with this for now because partial specializations can't have default arguments, but we really should be forming the complete finalized argument list before checking satisfaction.

2767–2770

Likewise.

2881–2884

Is this check justified by some wording in the standard? Checking a dependent set of constraints (before we've done any deduction) seems surprising.

(I asked this on the core reflector, and it sounds like the status quo answer is no: we should not check constraints before we have all the template arguments for a function template. I'm not convinced that's really the right answer going forward, but we can at least run with it for the time being, to collect evidence to support a different rule if nothing else.)

[thakis]

The mangling test fails on Windows:
http://lab.llvm.org:8011/builders/clang-x64-ninja-win7/builds/15944

It also fails on ppc64le:
http://lab.llvm.org:8011/builders/clang-ppc64le-linux-lnt/builds/21092

Please watch http://lab.llvm.org:8011/console for a bit after landing changes.

[thakis]

reverted in r374985, it wasn't obvious to me how to unbreak the test. Sorry!

[saar.raz]

Address CR comments by rsmith.

[rsmith]

clang/lib/Sema/SemaOverload.cpp

594 ↗

(On Diff #225418)

Please add a documentation comment.

10707 ↗

(On Diff #225418)

I think we should probably rank this higher -- maybe at the same level as a deduction or substitution failure, or maybe just above that. But I'm happy to wait and iterate on that once we have library code to experiment with.

clang/lib/Sema/SemaTemplate.cpp

4235 ↗

(On Diff #225418)

(Not directly related to this patch, feel free to address separately:) Passing false for UpdateArgsWithConversion here seems surprising: shouldn't we be using the converted arguments in the satisfaction check and storing the converted arguments on the AST?

[saar.raz]

Committed ffa214ef22892d75340dc6720271863901dc2c90

[vlad.tsyrklevich]

I noticed in Decl.cpp your change deleted some whitespace that belonged there. Not a big deal, just try to remember to run clang-format-diff when you're submitting for review. Thanks!

include/clang/AST/ExprCXX.h

protected:
 
   /// \brief The location of the concept name in the expression.
   SourceLocation ConceptNameLoc;
 
   /// \brief Whether or not the concept with the given arguments was satisfied
   /// when the expression was created. If any of the template arguments are
   /// dependent (this expr would then be isValueDependent()), this is to be
   /// ignored.
-  bool IsSatisfied : 1;
+  bool IsSatisfied;
 
-  /// \brief Evaluates this concept specialization to determine whether or not
-  /// the concept is satisfied. Returns true if an error occured and the concept
-  /// could not be checked for satisfaction.
-  bool evaluate(Sema &S);
+  /// \brief The concept's constraint expression with the template arguments
+  /// substituted in. To be used in diagnostics. If any of the template
+  /// arguments are dependent (this expr would then be isValueDependent()), this
+  /// is to be ignored.
+  Expr *SubstitutedConstraintExpr;
+
+  /// \brief If the concept's constraint expression was not satisfied because of
+  /// an ill-formed substitution, this contains diagnostics emitted when
+  /// substituting the template arguments into the constraint expression, to be
+  /// used in elaborated diagnostics.
+  llvm::Optional<PartialDiagnosticAt> SubstDiagnostic;
 
 public:
   ConceptSpecializationExpr(ASTContext &C, Sema &S,
                             SourceLocation ConceptNameLoc, ConceptDecl *CD,
                             const TemplateArgumentListInfo *TALI);
 
   ConceptSpecializationExpr(ASTContext &C);
 
assert(!isValueDependent()
            && "isSatisfied called on a dependent ConceptSpecializationExpr");
     return IsSatisfied;
   }
 
   void setSatisfied(bool Satisfied) {
     IsSatisfied = Satisfied;
   }
 
+  Expr *getSubstitutedConstraintExpr() const {
+    return SubstitutedConstraintExpr;
+  }
+
+  void setSubstitutedConstraintExpr(Expr *SCE) {
+    SubstitutedConstraintExpr = SCE;
+  }
+
   SourceLocation getConceptNameLoc() const { return ConceptNameLoc; }
   void setConceptNameLoc(SourceLocation Loc) {
     ConceptNameLoc = Loc;
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ConceptSpecializationExprClass;
   }

include/clang/Basic/DiagnosticSemaKinds.td

def err_concept_specialized : Error<
   "%select{explicitly instantiated|explicitly specialized|partially specialized}1">;
 def err_concept_decls_may_only_appear_in_global_namespace_scope : Error<
   "concept declarations may only appear in global or namespace scope">;
 def err_concept_extra_headers : Error<
   "extraneous template parameter list in concept definition">;
 def err_concept_no_associated_constraints : Error<
   "concept may not have associated constraints">;
 def err_concept_non_constant_constraint_expression : Error<
-  "concept specialization '%0' resulted in a non-constant expression '%1'.">;
+  "substitution into constraint expression resulted in a non-constant expression '%0'">;
 def err_non_bool_atomic_constraint : Error<
   "atomic constraint '%0' must be of type 'bool' (found %1)">;
 def note_in_concept_specialization : Note<
   "in concept specialization '%0'">;
+def err_template_arg_list_constraints_not_satisfied : Error<
+  "constraints not satisfied for %select{class template|function template|variable template|alias template|"
+  "template template parameter|template}0 %1%2, because:">;
+def note_constraints_not_satisfied : Note<
+  "constraints not satisfied">;
+def note_substituted_constraint_expr_is_ill_formed : Note<
+  "substituted constraint expression '%0' is ill-formed%1">;
+def note_substituted_constraint_expr_is_ill_formed_no_expr : Note<
+  "substituted constraint expression is ill-formed%0">;
+def note_atomic_constraint_evaluated_to_false : Note<
+  "%select{and |}0'%1' evaluated to false">;
+def note_concept_specialization_constraint_evaluated_to_false : Note<
+  "%select{and |}0'%1' evaluated to false, because:">;
+def note_single_arg_concept_specialization_constraint_evaluated_to_false : Note<
+  "%select{and |}0%1 does not satisfy %2, because:">;
+def note_atomic_constraint_evaluated_to_false_elaborated : Note<
+  "%select{and |}0'%1' (%2 %3 %4) evaluated to false">;
 
 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;
def note_ovl_candidate_inconsistent_deduction : Note<
     "templates}0 for parameter %1%diff{ ($ vs. $)|}2,3">;
 def note_ovl_candidate_inconsistent_deduction_types : Note<
     "candidate template ignored: deduced values %diff{"
     "of conflicting types for parameter %0 (%1 of type $ vs. %3 of type $)|"
     "%1 and %3 of conflicting types for parameter %0}2,4">;
 def note_ovl_candidate_explicit_arg_mismatch_named : Note<
     "candidate template ignored: invalid explicitly-specified argument "
     "for template parameter %0">;
+def note_ovl_candidate_unsatisfied_constraints : Note<
+    "candidate template ignored: constraints not satisfied%0">;
 def note_ovl_candidate_explicit_arg_mismatch_unnamed : Note<
     "candidate template ignored: invalid explicitly-specified argument "
     "for %ordinal0 template parameter">;
 def note_ovl_candidate_instantiation_depth : Note<
     "candidate template ignored: substitution exceeded maximum template "
     "instantiation depth">;
 def note_ovl_candidate_underqualified : Note<
     "candidate template ignored: cannot deduce a type for %0 that would "

include/clang/Sema/Sema.h

ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
                                            SourceLocation ConvLocation,
                                            CXXConversionDecl *Conv,
                                            Expr *Src);
 
   ExprResult CreateConceptSpecializationExpr(SourceLocation ConceptNameLoc,
                                              ConceptDecl *CTD,
                                        const TemplateArgumentListInfo *TALI);
 
-  /// Check whether the given expression is a valid constraint expression.
-  /// A diagnostic is emmited if it is not, and false is returned.
+  /// \brief Check whether the given expression is a valid constraint
+  /// expression. A diagnostic is emmited if it is not, and false is returned.
   bool CheckConstraintExpression(Expr *CE);
 
+  /// \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).
+  ///
+  /// \param SubstDiag if the constraint was not satisfied because of a
+  /// substitution failure, this will contain the emitted diagnostics, if any.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool CheckConstraintSatisfaction(TemplateDecl *Template,
+                                   const Expr *ConstraintExpr,
+                                   ArrayRef<TemplateArgument> TemplateArgs,
+                                   SourceLocation TemplateNameLoc,
+                                   bool &IsSatisfied,
+                                   ExprResult &SubstitutedExpression,
+                                llvm::Optional<PartialDiagnosticAt>& SubstDiag);
+
+  bool CheckConstraintSatisfaction(ClassTemplatePartialSpecializationDecl *TD,
+                                   const Expr *ConstraintExpr,
+                                   ArrayRef<TemplateArgument> TemplateArgs,
+                                   SourceLocation TemplateNameLoc,
+                                   bool &IsSatisfied,
+                                   ExprResult &SubstitutedExpression,
+                                llvm::Optional<PartialDiagnosticAt>& SubstDiag);
+
+  bool CheckConstraintSatisfaction(VarTemplatePartialSpecializationDecl *TD,
+                                   const Expr *ConstraintExpr,
+                                   ArrayRef<TemplateArgument> TemplateArgs,
+                                   SourceLocation TemplateNameLoc,
+                                   bool &IsSatisfied,
+                                   ExprResult &SubstitutedExpression,
+                                llvm::Optional<PartialDiagnosticAt>& SubstDiag);
+
   /// \brief Check that the associated constraints of a template declaration
   /// match the associated constraints of an older declaration of which it is a
   /// redeclaration
   bool CheckRedeclarationConstraintMatch(const Expr *OldAC, const Expr *NewAC);
 
+  /// \brief Ensure that the given template arguments satisfy the constraints
+  /// associated with the given template, emitting a diagnostic if they do not.
+  ///
+  /// \param Template The template to which the template arguments are being
+  /// provided.
+  ///
+  /// \param TemplateArgs The converted, canonicalized template arguments.
+  ///
+  /// \param TemplateNameLoc Where was the template name that evoked this
+  /// constraints check.
+  ///
+  /// \returns true if the constrains are not satisfied or could not be checked
+  /// for satisfaction, false if the constraints are satisfied.
+  bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,
+                                       ArrayRef<TemplateArgument> TemplateArgs,
+                                             SourceLocation TemplateNameLoc);
+
+  /// \brief Emit diagnostics explaining why a constraint expression was deemed
+  /// unsatisfied.
+  void DiagnoseUnsatisfiedConstraint(ExprResult SubstitutedConstraintExpr,
+                                     PartialDiagnosticAt *PDiag);
+
   // 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 *"
enum TemplateDeductionResult {
     /// \brief When performing template argument deduction for a function
     /// template, there were too few call arguments.
     TDK_TooFewArguments,
     /// \brief The explicitly-specified template arguments were not valid
     /// template arguments for the given template.
     TDK_InvalidExplicitArguments,
     /// \brief Checking non-dependent argument conversions failed.
     TDK_NonDependentConversionFailure,
+    /// \brief The deduced arguments did not satisfy the constraints associated
+    /// with the template.
+    TDK_ConstraintsNotSatisfied,
     /// \brief Deduction failed; that's all we know.
     TDK_MiscellaneousDeductionFailure,
     /// \brief CUDA Target attributes do not match.
     TDK_CUDATargetMismatch
   };
 
   TemplateDeductionResult
   DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,

include/clang/Sema/TemplateDeduction.h

 //===- TemplateDeduction.h - C++ template argument deduction ----*- C++ -*-===/
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //===----------------------------------------------------------------------===/
 //
 //  This file provides types used with Sema's template argument deduction
 // routines.
 //
 //===----------------------------------------------------------------------===/
 #ifndef LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H
 #define LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H
 
+#include "clang/Sema/Ownership.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace clang {
 
 struct DeducedPack;
 class TemplateArgumentList;
public:
   ///   TDK_DeducedMismatch: this is the index of the argument that had a
   ///   different argument type from its substituted parameter type.
   unsigned CallArgIndex;
 
   /// \brief Information on packs that we're currently expanding.
   ///
   /// FIXME: This should be kept internal to SemaTemplateDeduction.
   SmallVector<DeducedPack *, 8> PendingDeducedPacks;
+
+  /// \brief The substituted constraint expression used to determine whether the
+  /// associated constraints were satisfied.
+  ExprResult SubstitutedConstraintExpr;
 };
 
 } // end namespace sema
 
 /// A structure used to record information about a failed
 /// template argument deduction, for diagnosis.
 struct DeductionFailureInfo {
   /// A Sema::TemplateDeductionResult.

lib/AST/ExprCXX.cpp

: Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary,
          /*ContainsUnexpandedParameterPacks=*/false), SpecializedConcept(CD),
     ConceptNameLoc(ConceptNameLoc) {
   setTemplateArguments(&S, TALI);
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(ASTContext &C)
   : Expr(ConceptSpecializationExprClass, EmptyShell()) { }
 
-bool ConceptSpecializationExpr::evaluate(Sema &S)
-{
-  llvm::SmallVector<TemplateArgument, 4> Converted;
-  if (S.CheckTemplateArgumentList(SpecializedConcept,
-                                  SpecializedConcept->getLocStart(),
-                                  TemplateArgInfo,
-                                  /*PartialTemplateArgs=*/false, Converted,
-                                  /*UpdateArgsWithConversion=*/false)) {
-    // We converted these arguments back in CheckConceptTemplateId, this should
-    // work.
-    return true;
-  }
-  EnterExpressionEvaluationContext ConstantEvaluated(
-          S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-
-
-  MultiLevelTemplateArgumentList MLTAL;
-  MLTAL.addOuterTemplateArguments(Converted);
-
-  ExprResult E;
-  {
-    // We do not want error diagnostics escaping here.
-    Sema::SFINAETrap Trap(S);
-    E = S.SubstExpr(SpecializedConcept->getConstraintExpr(), MLTAL);
-    if (E.isInvalid() || Trap.hasErrorOccurred()) {
-      // C++2a [temp.constr.atomic]p1
-      //   ...If substitution results in an invalid type or expression, the
-      //   constraint is not satisfied.
-      IsSatisfied = false;
-      return true;
-    }
-  }
-
-  if (!S.CheckConstraintExpression(E.get())) {
-    S.Diag(getLocStart(), diag::note_in_concept_specialization) << this;
-    return true;
-  }
-
-  bool Satisfied = false;
-  if (!E.get()->EvaluateAsBooleanCondition(Satisfied, S.Context)) {
-      // C++2a [temp.constr.atomic]p1
-      //   ...E shall be a constant expression of type bool.
-    S.Diag(getLocStart(), diag::err_concept_non_constant_constraint_expression)
-      << this << E.get();
-    return true;
-  }
-  IsSatisfied = Satisfied;
-  return false;
-}
-
 bool ConceptSpecializationExpr::setTemplateArguments(Sema *S,
                                           const TemplateArgumentListInfo *TALI){
   bool IsDependent = false;
   bool ContainsUnexpandedParameterPack = false;
   TemplateArgInfo = *TALI;
   for (const TemplateArgumentLoc& LocInfo : TALI->arguments()) {
     if (LocInfo.getArgument().isInstantiationDependent()) {
       IsDependent = true;
       if (ContainsUnexpandedParameterPack) {
         break;
       }
     }
     if (LocInfo.getArgument().containsUnexpandedParameterPack()) {
       ContainsUnexpandedParameterPack = true;
       if (IsDependent) {
         break;
       }
     }
   }
   setValueDependent(IsDependent);
   setInstantiationDependent(IsDependent);
   setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack);
   if (!IsDependent && S) {
-    return evaluate(*S);
+    llvm::SmallVector<TemplateArgument, 4> Converted;
+    if (S->CheckTemplateArgumentList(SpecializedConcept,
+                                     SpecializedConcept->getLocStart(),
+                                     TemplateArgInfo,
+                                     /*PartialTemplateArgs=*/false, Converted,
+                                     /*UpdateArgsWithConversion=*/false)) {
+      // We converted these arguments back in CheckConceptTemplateId, this should
+      // work.
+      return true;
+    }
+    ExprResult SubstitutedExpression;
+    if (S->CheckConstraintSatisfaction(SpecializedConcept,
+                                       SpecializedConcept->getConstraintExpr(),
+                                       Converted, ConceptNameLoc, IsSatisfied,
+                                       SubstitutedExpression, SubstDiagnostic)){
+      S->Diag(getLocStart(), diag::note_in_concept_specialization) << this;
+      return true;
+    }
+    SubstitutedConstraintExpr = SubstitutedExpression.get();
   }
   return false;
 }
 No newline at end of file

lib/Sema/SemaOverload.cpp

struct DFIParamWithArguments : DFIArguments {
     TemplateParameter Param;
   };
   // Structure used by DeductionFailureInfo to store template argument
   // information and the index of the problematic call argument.
   struct DFIDeducedMismatchArgs : DFIArguments {
     TemplateArgumentList *TemplateArgs;
     unsigned CallArgIndex;
   };
+  struct CNSInfo {
+    TemplateArgumentList *TemplateArgs;
+    ExprResult SubstitutedConstraintExpr;
+  };
 }
 
 /// \brief Convert from Sema's representation of template deduction information
 /// to the form used in overload-candidate information.
 DeductionFailureInfo
 clang::MakeDeductionFailureInfo(ASTContext &Context,
                                 Sema::TemplateDeductionResult TDK,
                                 TemplateDeductionInfo &Info) {
case Sema::TDK_SubstitutionFailure:
     if (Info.hasSFINAEDiagnostic()) {
       PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
           SourceLocation(), PartialDiagnostic::NullDiagnostic());
       Info.takeSFINAEDiagnostic(*Diag);
       Result.HasDiagnostic = true;
     }
     break;
 
+  case Sema::TDK_ConstraintsNotSatisfied: {
+    CNSInfo *Saved = new (Context) CNSInfo;
+    Saved->TemplateArgs = Info.take();
+    Saved->SubstitutedConstraintExpr = Info.SubstitutedConstraintExpr;
+    Result.Data = Saved;
+
+    if (Info.hasSFINAEDiagnostic()) {
+      PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
+          SourceLocation(), PartialDiagnostic::NullDiagnostic());
+      Info.takeSFINAEDiagnostic(*Diag);
+      Result.HasDiagnostic = true;
+    }
+    break;
+  }
+
   case Sema::TDK_Success:
   case Sema::TDK_NonDependentConversionFailure:
     llvm_unreachable("not a deduction failure");
   }
 
   return Result;
 }
 
case Sema::TDK_SubstitutionFailure:
     // FIXME: Destroy the template argument list?
     Data = nullptr;
     if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
       Diag->~PartialDiagnosticAt();
       HasDiagnostic = false;
     }
     break;
 
+  case Sema::TDK_ConstraintsNotSatisfied:
+    // FIXME: Destroy the template argument list?
+    Data = nullptr;
+    if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
+      Diag->~PartialDiagnosticAt();
+      HasDiagnostic = false;
+    }
+    break;
+
   // Unhandled
   case Sema::TDK_MiscellaneousDeductionFailure:
     break;
   }
 }
 
 PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
   if (HasDiagnostic)
TemplateParameter DeductionFailureInfo::getTemplateParameter() {
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_SubstitutionFailure:
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_DeducedMismatchNested:
   case Sema::TDK_NonDeducedMismatch:
   case Sema::TDK_CUDATargetMismatch:
   case Sema::TDK_NonDependentConversionFailure:
+  case Sema::TDK_ConstraintsNotSatisfied:
     return TemplateParameter();
 
   case Sema::TDK_Incomplete:
   case Sema::TDK_InvalidExplicitArguments:
     return TemplateParameter::getFromOpaqueValue(Data);
 
   case Sema::TDK_Inconsistent:
   case Sema::TDK_Underqualified:
TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
 
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_DeducedMismatchNested:
     return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
 
   case Sema::TDK_SubstitutionFailure:
     return static_cast<TemplateArgumentList*>(Data);
 
+  case Sema::TDK_ConstraintsNotSatisfied:
+    return static_cast<CNSInfo*>(Data)->TemplateArgs;
+
   // Unhandled
   case Sema::TDK_MiscellaneousDeductionFailure:
     break;
   }
 
   return nullptr;
 }
 
 const TemplateArgument *DeductionFailureInfo::getFirstArg() {
   switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
   case Sema::TDK_Success:
   case Sema::TDK_Invalid:
   case Sema::TDK_InstantiationDepth:
   case Sema::TDK_Incomplete:
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_InvalidExplicitArguments:
   case Sema::TDK_SubstitutionFailure:
   case Sema::TDK_CUDATargetMismatch:
   case Sema::TDK_NonDependentConversionFailure:
+  case Sema::TDK_ConstraintsNotSatisfied:
     return nullptr;
 
   case Sema::TDK_Inconsistent:
   case Sema::TDK_Underqualified:
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_DeducedMismatchNested:
   case Sema::TDK_NonDeducedMismatch:
     return &static_cast<DFIArguments*>(Data)->FirstArg;
const TemplateArgument *DeductionFailureInfo::getSecondArg() {
   case Sema::TDK_InstantiationDepth:
   case Sema::TDK_Incomplete:
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_InvalidExplicitArguments:
   case Sema::TDK_SubstitutionFailure:
   case Sema::TDK_CUDATargetMismatch:
   case Sema::TDK_NonDependentConversionFailure:
+  case Sema::TDK_ConstraintsNotSatisfied:
     return nullptr;
 
   case Sema::TDK_Inconsistent:
   case Sema::TDK_Underqualified:
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_DeducedMismatchNested:
   case Sema::TDK_NonDeducedMismatch:
     return &static_cast<DFIArguments*>(Data)->SecondArg;
else {
         index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
       S.Diag(Templated->getLocation(),
              diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
           << (index + 1);
     }
     MaybeEmitInheritedConstructorNote(S, Found);
     return;
 
+  case Sema::TDK_ConstraintsNotSatisfied: {
+    // Format the template argument list into the argument string.
+    SmallString<128> TemplateArgString;
+    TemplateArgumentList *Args = DeductionFailure.getTemplateArgumentList();
+    TemplateArgString = " ";
+    TemplateArgString += S.getTemplateArgumentBindingsText(
+        getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
+    S.Diag(Templated->getLocation(),
+           diag::note_ovl_candidate_unsatisfied_constraints)
+        << TemplateArgString;
+
+    S.DiagnoseUnsatisfiedConstraint(
+       static_cast<CNSInfo*>(DeductionFailure.Data)->SubstitutedConstraintExpr,
+       DeductionFailure.getSFINAEDiagnostic());
+    return;
+  }
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
     DiagnoseArityMismatch(S, Found, Templated, NumArgs);
     return;
 
   case Sema::TDK_InstantiationDepth:
     S.Diag(Templated->getLocation(),
            diag::note_ovl_candidate_instantiation_depth);
static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
   case Sema::TDK_SubstitutionFailure:
   case Sema::TDK_DeducedMismatch:
   case Sema::TDK_DeducedMismatchNested:
   case Sema::TDK_NonDeducedMismatch:
   case Sema::TDK_MiscellaneousDeductionFailure:
   case Sema::TDK_CUDATargetMismatch:
     return 3;
 
-  case Sema::TDK_InstantiationDepth:
+  case Sema::TDK_ConstraintsNotSatisfied:
     return 4;
 
-  case Sema::TDK_InvalidExplicitArguments:
+  case Sema::TDK_InstantiationDepth:
     return 5;
 
+  case Sema::TDK_InvalidExplicitArguments:
+    return 6;
+
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
-    return 6;
+    return 7;
   }
   llvm_unreachable("Unhandled deduction result");
 }
 
 namespace {
 struct CompareOverloadCandidatesForDisplay {
   Sema &S;
   SourceLocation Loc;

lib/Sema/SemaTemplate.cpp

if (DTN && DTN->isIdentifier())
     // dependent name is substituted.
     return Context.getDependentTemplateSpecializationType(ETK_None,
                                                           DTN->getQualifier(),
                                                           DTN->getIdentifier(),
                                                           TemplateArgs);
 
   TemplateDecl *Template = Name.getAsTemplateDecl();
   if (!Template || isa<FunctionTemplateDecl>(Template) ||
-      isa<VarTemplateDecl>(Template) ||
-      isa<ConceptDecl>(Template)) {
+      isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
     // We might have a substituted template template parameter pack. If so,
     // build a template specialization type for it.
     if (Name.getAsSubstTemplateTemplateParmPack())
       return Context.getTemplateSpecializationType(Name, TemplateArgs);
 
     Diag(TemplateLoc, diag::err_template_id_not_a_type)
       << Name;
     NoteAllFoundTemplates(Name);
     return QualType();
   }
 
   // Check that the template argument list is well-formed for this
   // template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
                                 false, Converted))
     return QualType();
 
+  if (EnsureTemplateArgumentListConstraints(Template, Converted, TemplateLoc))
+    return QualType();
+
   QualType CanonType;
 
   bool InstantiationDependent = false;
   if (TypeAliasTemplateDecl *AliasTemplate =
           dyn_cast<TypeAliasTemplateDecl>(Template)) {
+
     // Find the canonical type for this type alias template specialization.
     TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
     if (Pattern->isInvalidDecl())
       return QualType();
 
     TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
                                            Converted);
 
DeclResult Sema::ActOnVarTemplateSpecialization(
 
   // Check that the template argument list is well-formed for this
   // template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
                                 false, Converted))
     return true;
 
+  if (EnsureTemplateArgumentListConstraints(VarTemplate, Converted,
+                                            TemplateNameLoc))
+    return true;
+
   // Find the variable template (partial) specialization declaration that
   // corresponds to these arguments.
   if (IsPartialSpecialization) {
     if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, VarTemplate,
                                                TemplateArgs.size(), Converted))
       return true;
 
     // FIXME: Move these checks to CheckTemplatePartialSpecializationArgs so we
Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
   // Check that the template argument list is well-formed for this template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(
           Template, TemplateNameLoc,
           const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
           Converted))
     return true;
 
+  if (EnsureTemplateArgumentListConstraints(Template, Converted,
+                                            TemplateNameLoc))
+    return true;
+
   // Find the variable template specialization declaration that
   // corresponds to these arguments.
   void *InsertPos = nullptr;
   if (VarTemplateSpecializationDecl *Spec = Template->findSpecialization(
           Converted, InsertPos)) {
     checkSpecializationVisibility(TemplateNameLoc, Spec);
     // If we already have a variable template specialization, return it.
     return Spec;
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
   }
 
   // FIXME: If there's a more recent default argument that *is* visible,
   // diagnose that it was declared too late.
 
   return diagnoseArityMismatch(S, TD, Loc, Args);
 }
 
+template<typename TemplateDeclT>
+bool CheckConstraintSatisfaction(Sema &S, TemplateDeclT *Template,
+                                 const Expr *ConstraintExpr,
+                                 ArrayRef<TemplateArgument> TemplateArgs,
+                                 SourceLocation TemplateNameLoc,
+                                 bool &IsSatisfied,
+                                 ExprResult &SubstitutedExpression,
+                               llvm::Optional<PartialDiagnosticAt>& SubstDiag) {
+  if (!ConstraintExpr) {
+    IsSatisfied = true;
+    SubstitutedExpression.set(nullptr);
+    return false;
+  }
+
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+
+  MultiLevelTemplateArgumentList MLTAL;
+  MLTAL.addOuterTemplateArguments(TemplateArgs);
+
+  {
+    // We do not want error diagnostics escaping here.
+    TemplateDeductionInfo Info(TemplateNameLoc);
+    Sema::InstantiatingTemplate Inst(S, TemplateNameLoc, Template, TemplateArgs,
+                                     Info);
+    Sema::SFINAETrap Trap(S);
+
+    SubstitutedExpression = S.SubstExpr(const_cast<Expr*>(ConstraintExpr),
+                                        MLTAL);
+    if (SubstitutedExpression.isInvalid() || !SubstitutedExpression.isUsable()
+        || Trap.hasErrorOccurred()) {
+      // C++2a [temp.constr.atomic]p1
+      //   ...If substitution results in an invalid type or expression, the
+      //   constraint is not satisfied.
+      if (Trap.hasErrorOccurred()) {
+        SubstDiag = PartialDiagnosticAt{ SourceLocation(),
+                                         PartialDiagnostic::NullDiagnostic() };
+        Info.takeSFINAEDiagnostic(SubstDiag.getValue());
+      }
+      IsSatisfied = false;
+      return false;
+    }
+  }
+
+  if (!S.CheckConstraintExpression(SubstitutedExpression.get())) {
+    return true;
+  }
+
+  if (SubstitutedExpression.get()->isInstantiationDependent()) {
+    IsSatisfied = true;
+    return false;
+  }
+
+  bool Satisfied = false;
+  if (!SubstitutedExpression.get()->EvaluateAsBooleanCondition(Satisfied,
+                                                               S.Context)) {
+      // C++2a [temp.constr.atomic]p1
+      //   ...E shall be a constant expression of type bool.
+    S.Diag(ConstraintExpr->getLocStart(),
+         diag::err_concept_non_constant_constraint_expression)
+        << SubstitutedExpression.get();
+    return true;
+  }
+  IsSatisfied = Satisfied;
+  return false;
+}
+
+bool Sema::CheckConstraintSatisfaction(TemplateDecl *Template,
+                                       const Expr *ConstraintExpr,
+                                       ArrayRef<TemplateArgument> TemplateArgs,
+                                       SourceLocation TemplateNameLoc,
+                                       bool &IsSatisfied,
+                                       ExprResult &SubstitutedExpression,
+                               llvm::Optional<PartialDiagnosticAt>& SubstDiag) {
+  return ::CheckConstraintSatisfaction(*this, Template, ConstraintExpr,
+                                       TemplateArgs, TemplateNameLoc,
+                                       IsSatisfied, SubstitutedExpression,
+                                       SubstDiag);
+}
+
+bool
+Sema::CheckConstraintSatisfaction(ClassTemplatePartialSpecializationDecl* Part,
+                                  const Expr *ConstraintExpr,
+                                  ArrayRef<TemplateArgument> TemplateArgs,
+                                  SourceLocation TemplateNameLoc,
+                                  bool &IsSatisfied,
+                                  ExprResult &SubstitutedExpression,
+                               llvm::Optional<PartialDiagnosticAt>& SubstDiag) {
+  return ::CheckConstraintSatisfaction(*this, Part, ConstraintExpr,
+                                       TemplateArgs, TemplateNameLoc,
+                                       IsSatisfied, SubstitutedExpression,
+                                       SubstDiag);
+}
+
+bool
+Sema::CheckConstraintSatisfaction(VarTemplatePartialSpecializationDecl* Partial,
+                                  const Expr *ConstraintExpr,
+                                  ArrayRef<TemplateArgument> TemplateArgs,
+                                  SourceLocation TemplateNameLoc,
+                                  bool &IsSatisfied,
+                                  ExprResult &SubstitutedExpression,
+                               llvm::Optional<PartialDiagnosticAt>& SubstDiag) {
+  return ::CheckConstraintSatisfaction(*this, Partial, ConstraintExpr,
+                                       TemplateArgs, TemplateNameLoc,
+                                       IsSatisfied, SubstitutedExpression,
+                                       SubstDiag);
+}
+
+bool Sema::EnsureTemplateArgumentListConstraints(TemplateDecl *TD,
+                                     ArrayRef<TemplateArgument> TemplateArgs,
+                                               SourceLocation TemplateNameLoc) {
+  bool IsSatisfied;
+  ExprResult SubstitutedConstraintExpr;
+  llvm::Optional<PartialDiagnosticAt> SubstDiag;
+  if (CheckConstraintSatisfaction(TD, TD->getAssociatedConstraints(),
+                                  TemplateArgs, TemplateNameLoc, IsSatisfied,
+                                  SubstitutedConstraintExpr, SubstDiag))
+    return true;
+
+  if (!IsSatisfied) {
+    SmallString<128> TemplateArgString;
+    TemplateArgString = " ";
+    TemplateArgString += getTemplateArgumentBindingsText(
+        TD->getTemplateParameters(), TemplateArgs.data(), TemplateArgs.size());
+    Diag(TemplateNameLoc, diag::err_template_arg_list_constraints_not_satisfied)
+        << (int)getTemplateNameKindForDiagnostics(TemplateName(TD)) << TD
+        << TemplateArgString;
+    DiagnoseUnsatisfiedConstraint(SubstitutedConstraintExpr,
+                                  SubstDiag.getPointer());
+    return true;
+  }
+  return false;
+}
+
+static void diagnoseUnsatisfiedConstraintExpr(Sema &S, Expr *E,
+                                              bool First = true) {
+  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    switch(BO->getOpcode()) {
+      case BO_LAnd: {
+        // Either LHS or RHS evaluated to false.
+        bool Result = false;
+        BO->getLHS()->EvaluateAsBooleanCondition(Result, S.Context);
+        if (Result) {
+          // LHS evaluated to true - therefore RHS evaluated to false.
+          diagnoseUnsatisfiedConstraintExpr(S, BO->getRHS(), First);
+          return;
+        }
+        // LHS evaluated to false - diagnose it.
+        diagnoseUnsatisfiedConstraintExpr(S, BO->getLHS(), First);
+        return;
+      }
+
+      case BO_LOr:
+        // Both LHS and RHS evaluated to false.
+        diagnoseUnsatisfiedConstraintExpr(S, BO->getLHS(), First);
+        diagnoseUnsatisfiedConstraintExpr(S, BO->getRHS(), /*First=*/false);
+        return;
+
+      case BO_GE:
+      case BO_LE:
+      case BO_GT:
+      case BO_LT:
+      case BO_EQ:
+      case BO_NE:
+        if (BO->getLHS()->getType()->isIntegerType() &&
+            BO->getRHS()->getType()->isIntegerType()) {
+          llvm::APSInt SimplifiedLHS;
+          llvm::APSInt SimplifiedRHS;
+          BO->getLHS()->EvaluateAsInt(SimplifiedLHS, S.Context);
+          BO->getRHS()->EvaluateAsInt(SimplifiedRHS, S.Context);
+          S.Diag(E->getSourceRange().getBegin(),
+                 diag::note_atomic_constraint_evaluated_to_false_elaborated)
+              << (int) First << E << SimplifiedLHS.toString(10)
+              << BinaryOperator::getOpcodeStr(BO->getOpcode())
+              << SimplifiedRHS.toString(10);
+          return;
+        }
+        break;
+
+      default:
+        break;
+    }
+  } else if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
+    diagnoseUnsatisfiedConstraintExpr(S, PE->getSubExpr(), First);
+    return;
+  } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) {
+    if (CSE->getTemplateArgumentListInfo()->size() == 1) {
+      S.Diag(E->getSourceRange().getBegin(),
+          diag::note_single_arg_concept_specialization_constraint_evaluated_to_false)
+          << (int)First
+          << CSE->getTemplateArgumentListInfo()->arguments()[0].getArgument()
+          << CSE->getSpecializedConcept();
+    } else {
+      S.Diag(E->getSourceRange().getBegin(),
+          diag::note_concept_specialization_constraint_evaluated_to_false)
+          << (int)First << E;
+    }
+    diagnoseUnsatisfiedConstraintExpr(S, CSE->getSubstitutedConstraintExpr(),
+                                      /*First=*/true);
+    return;
+  }
+  S.Diag(E->getSourceRange().getBegin(),
+         diag::note_atomic_constraint_evaluated_to_false) << (int)First << E;
+}
+
+void Sema::DiagnoseUnsatisfiedConstraint(ExprResult UnsatisfiedConstraintExpr,
+                                         PartialDiagnosticAt *PDiag) {
+  if (UnsatisfiedConstraintExpr.isInvalid()) {
+    SmallString<128> SFINAEArgString;
+    SourceRange R;
+    if (PDiag) {
+      SFINAEArgString = ": ";
+      R = SourceRange(PDiag->first, PDiag->first);
+      PDiag->second.EmitToString(getDiagnostics(), SFINAEArgString);
+    }
+    if (UnsatisfiedConstraintExpr.get())
+      Diag(UnsatisfiedConstraintExpr.get()->getLocStart(),
+           diag::note_substituted_constraint_expr_is_ill_formed)
+        << UnsatisfiedConstraintExpr.get() << SFINAEArgString << R;
+    else
+      Diag(R.getBegin(),
+           diag::note_substituted_constraint_expr_is_ill_formed_no_expr)
+        << SFINAEArgString << R;
+
+    return;
+  }
+  diagnoseUnsatisfiedConstraintExpr(*this, UnsatisfiedConstraintExpr.get());
+}
+
 /// \brief Check that the given template argument list is well-formed
 /// for specializing the given template.
 bool Sema::CheckTemplateArgumentList(
     TemplateDecl *Template, SourceLocation TemplateLoc,
     TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
     SmallVectorImpl<TemplateArgument> &Converted,
     bool UpdateArgsWithConversions) {
+
   // Make a copy of the template arguments for processing.  Only make the
   // changes at the end when successful in matching the arguments to the
   // template.
   TemplateArgumentListInfo NewArgs = TemplateArgs;
 
   // Make sure we get the template parameter list from the most
   // recentdeclaration, since that is the only one that has is guaranteed to
   // have all the default template argument information.
Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
 
   // Check that the template argument list is well-formed for this
   // template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
                                 TemplateArgs, false, Converted))
     return true;
 
+  if (EnsureTemplateArgumentListConstraints(ClassTemplate, Converted,
+                                            TemplateNameLoc))
+    return true;
+
   // Find the class template (partial) specialization declaration that
   // corresponds to these arguments.
   if (isPartialSpecialization) {
     if (CheckTemplatePartialSpecializationArgs(TemplateNameLoc, ClassTemplate,
                                                TemplateArgs.size(), Converted))
       return true;
 
     // FIXME: Move this to CheckTemplatePartialSpecializationArgs so we
     // also do it during instantiation.
Sema::ActOnExplicitInstantiation(Scope *S,
 
   // Check that the template argument list is well-formed for this
   // template.
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
                                 TemplateArgs, false, Converted))
     return true;
 
+  if (EnsureTemplateArgumentListConstraints(ClassTemplate, Converted,
+                                            TemplateNameLoc)) {
+    return true;
+  }
+
   // Find the class template specialization declaration that
   // corresponds to these arguments.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl
     = ClassTemplate->findSpecialization(Converted, InsertPos);
 
   TemplateSpecializationKind PrevDecl_TSK
     = PrevDecl ? PrevDecl->getTemplateSpecializationKind() : TSK_Undeclared;

lib/Sema/SemaTemplateDeduction.cpp

static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction(
   }
 
   if (Trap.hasErrorOccurred())
     return Sema::TDK_SubstitutionFailure;
 
   return Sema::TDK_Success;
 }
 
+template<typename TemplateDeclT>
+static Sema::TemplateDeductionResult
+CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
+                                ArrayRef<TemplateArgument> DeducedArgs,
+                                TemplateDeductionInfo& Info) {
+  bool IsSatisfied = false;
+  ExprResult SubstitutedExpr;
+  llvm::Optional<PartialDiagnosticAt> SubstDiag;
+  if (S.CheckConstraintSatisfaction(Template,
+                                    Template->getAssociatedConstraints(),
+                                    DeducedArgs, Info.getLocation(),
+                                    IsSatisfied, SubstitutedExpr, SubstDiag)
+      || !IsSatisfied) {
+    if (SubstDiag)
+      Info.addSFINAEDiagnostic(SubstDiag->first, SubstDiag->second);
+    Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
+    Info.SubstitutedConstraintExpr = SubstitutedExpr;
+    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,
                               const TemplateArgumentList &TemplateArgs,
                               TemplateDeductionInfo &Info) {
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(
   //   explicitly specified, template argument deduction fails.
   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,
+                                          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
   //   compared with the corresponding arguments. For each remaining parameter
   //   P with a type that was non-dependent before substitution of any
   //   explicitly-specified template arguments, if the corresponding argument

 /// \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

lib/Sema/SemaTemplateInstantiateDecl.cpp

TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
                                         D->getLocation(),
                                         InstTemplateArgs,
                                         false,
                                         Converted))
     return nullptr;
 
+  if (SemaRef.EnsureTemplateArgumentListConstraints(InstClassTemplate,
+                                                    Converted,
+                                                    D->getLocation())) {
+    return nullptr;
+  }
+
   // Figure out where to insert this class template explicit specialization
   // in the member template's set of class template explicit specializations.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl =
       InstClassTemplate->findSpecialization(Converted, InsertPos);
 
   // Check whether we've already seen a conflicting instantiation of this
   // declaration (for instance, if there was a prior implicit instantiation).
Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
   // Check that the template argument list is well-formed for this template.
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(
           VarTemplate, VarTemplate->getLocStart(),
           const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
           Converted))
     return nullptr;
 
+  if (SemaRef.EnsureTemplateArgumentListConstraints(VarTemplate, Converted,
+                                                   VarTemplate->getLocStart())){
+    return nullptr;
+  }
+
   // Find the variable template specialization declaration that
   // corresponds to these arguments.
   void *InsertPos = nullptr;
   if (VarTemplateSpecializationDecl *VarSpec = VarTemplate->findSpecialization(
           Converted, InsertPos))
     // If we already have a variable template specialization, return it.
     return VarSpec;
 

lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitConceptSpecializationExpr(
   TemplateArgumentListInfo ArgInfo;
   unsigned NumTemplateArgs = Record.readInt();
   ArgInfo.setLAngleLoc(Record.readSourceLocation());
   ArgInfo.setRAngleLoc(Record.readSourceLocation());
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
     ArgInfo.addArgument(Record.readTemplateArgumentLoc());
   E->setTemplateArguments(/*Sema=*/nullptr, &ArgInfo);
   E->setSatisfied(Record.readInt() == 1);
+  E->setSubstitutedConstraintExpr(Record.readExpr());
 }
 
 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
   E->setLHS(Record.readSubExpr());
   E->setRHS(Record.readSubExpr());
   E->setRBracketLoc(ReadSourceLocation());
 }

lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitConceptSpecializationExpr(
   const TemplateArgumentListInfo *TALI = E->getTemplateArgumentListInfo();
   Record.push_back(TALI->size());
   Record.AddSourceLocation(TALI->getLAngleLoc());
   Record.AddSourceLocation(TALI->getRAngleLoc());
   for (unsigned i = 0; i < TALI->size(); ++i) {
     Record.AddTemplateArgumentLoc(TALI->getArgumentArray()[i]);
   }
   Record.push_back(E->isSatisfied());
+  Record.AddStmt(E->getSubstitutedConstraintExpr());
   Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
 }
 
 
 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
   // NumCaptures
   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));

test/CXX/concepts-ts/expr/expr.prim/expr.prim.id/p3.cpp

struct A {
     }
 };
 struct B {
     static int add(int a, int b) {
         return a + b;
     }
 };
 template<typename U>
-concept C4 = U::add(1, 2) == 3;
+concept C4 = U::add(1, 2) == 3; // expected-error {{substitution into constraint expression resulted in a non-constant expression 'B::add(1, 2) == 3'}}
 static_assert(C4<A>);
-static_assert(!C4<B>); // expected-error {{concept specialization 'C4<B>' resulted in a non-constant expression 'B::add(1, 2) == 3'}}
+static_assert(!C4<B>); // expected-note {{in concept specialization 'C4<B>'}}
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;
 
 template<typename T, typename U>

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

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T>
+constexpr bool is_ptr_v = false;
+
+template<typename T>
+constexpr bool is_ptr_v<T*> = true;
+
+template<typename T, typename U>
+constexpr bool is_same_v = false;
+
+template<typename T>
+constexpr bool is_same_v<T, T> = true;
+
+template<typename T> requires is_ptr_v<T> // expected-note {{'is_ptr_v<int>' evaluated to false}} expected-note {{'is_ptr_v<char>' evaluated to false}}
+auto dereference(T t) { // expected-note {{candidate template ignored: constraints not satisfied [with T = int]}} expected-note {{candidate template ignored: constraints not satisfied [with T = char]}}
+  return *t;
+}
+
+static_assert(is_same_v<decltype(dereference<int*>(nullptr)), int>);
+static_assert(is_same_v<decltype(dereference(2)), int>); // expected-error {{no matching function for call to 'dereference'}}
+static_assert(is_same_v<decltype(dereference<char>('a')), char>); // expected-error {{no matching function for call to 'dereference'}}
+
+
+template<typename T> requires T{} + T{} // expected-note {{substituted constraint expression is ill-formed: invalid operands to binary expression ('A' and 'A')}}
+auto foo(T t) { // expected-note {{candidate template ignored: constraints not satisfied [with T = A]}}
+  return t + t;
+}
+
+struct A { };
+
+static_assert(foo(A{})); // expected-error {{no matching function for call to 'foo'}}
 No newline at end of file

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

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+template<typename T> requires sizeof(T) >= 2 // expected-note{{'sizeof(char) >= 2' (1 >= 2) evaluated to false}}
+struct A {
+  static constexpr int value = sizeof(T);
+};
+
+static_assert(A<int>::value == 4);
+static_assert(A<char>::value == 1); // expected-error{{constraints not satisfied for class template 'A' [with T = char], because:}}
+
+template<typename T, typename U>
+  requires sizeof(T) != sizeof(U) // expected-note{{'sizeof(int) != sizeof(char [4])' (4 != 4) evaluated to false}}
+           && sizeof(T) >= 4 // expected-note{{'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
+constexpr int SizeDiff = sizeof(T) > sizeof(U) ? sizeof(T) - sizeof(U) : sizeof(U) - sizeof(T);
+
+static_assert(SizeDiff<int, char> == 3);
+static_assert(SizeDiff<int, char[4]> == 0); // expected-error{{constraints not satisfied for variable template 'SizeDiff' [with T = int, U = char [4]], because:}}
+static_assert(SizeDiff<char, int> == 3); // expected-error{{constraints not satisfied for variable template 'SizeDiff' [with T = char, U = int], because:}}
+
+template<typename... Ts>
+  requires ((sizeof(Ts) == 4) || ...) // expected-note{{'sizeof(char) == 4' (1 == 4) evaluated to false}} expected-note{{'sizeof(long long) == 4' (8 == 4) evaluated to false}} expected-note{{'sizeof(int [20]) == 4' (80 == 4) evaluated to false}}
+constexpr auto SumSizes = (sizeof(Ts) + ...);
+
+static_assert(SumSizes<char, long long, int> == 13);
+static_assert(SumSizes<char, long long, int[20]> == 89); // expected-error{{constraints not satisfied for variable template 'SumSizes' [with Ts = <char, long long, int [20]>], because:}}
+
+template<typename T>
+concept IsBig = sizeof(T) > 100; // expected-note{{'sizeof(int) > 100' (4 > 100) evaluated to false}}
+
+template<typename T>
+  requires IsBig<T> // expected-note{{'int' does not satisfy 'IsBig', because:}}
+using BigPtr = T*;
+
+static_assert(sizeof(BigPtr<int>)); // expected-error{{constraints not satisfied for alias template 'BigPtr' [with T = int], because:}}}}
+
+template<typename T> requires T::value // expected-note{{substituted constraint expression is ill-formed: type 'int' cannot be used prior to '::' because it has no members}}
+struct S { static constexpr bool value = true; };
+
+struct S2 { static constexpr bool value = true; };
+
+static_assert(S<int>::value); // expected-error{{constraints not satisfied for class template 'S' [with T = int], because:}}
+static_assert(S<S2>::value);
 No newline at end of file

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

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ -verify %s
+
+namespace class_templates
+{
+  template<typename T, typename U> requires sizeof(T) >= 4 // expected-note {{'sizeof(char) >= 4' (1 >= 4) evaluated to false}}
+  struct is_same { static constexpr bool value = false; };
+
+  template<typename T> requires sizeof(T*) >= 4 && sizeof(T) >= 4
+  struct is_same<T*, T*> { static constexpr bool value = true; };
+
+  static_assert(!is_same<char*, char*>::value);
+  static_assert(!is_same<short*, short*>::value);
+  static_assert(is_same<int*, int*>::value);
+  static_assert(is_same<char, char>::value); // expected-error {{constraints not satisfied for class template 'is_same' [with T = char, U = char], because:}}
+}
+
+namespace variable_templates
+{
+  template<typename T, typename U> requires sizeof(T) >= 4
+  constexpr bool is_same_v = false;
+
+  template<typename T> requires sizeof(T*) >= 4 && sizeof(T) >= 4
+  constexpr bool is_same_v<T*, T*> = true;
+
+  static_assert(!is_same_v<char*, char*>);
+  static_assert(!is_same_v<short*, short*>);
+  static_assert(is_same_v<int*, int*>);
+}
 No newline at end of file