[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

104

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

7441–7443

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

 };
 
 /// \brief Represents the specialization of a concept - evaluates to a prvalue
 /// of type bool.
 ///
 /// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
 /// specialization of a concept results in a prvalue of type bool.
 class ConceptSpecializationExpr final : public Expr {
+public:
+  using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;
+
 protected:
   /// \brief The concept named.
   ConceptDecl *NamedConcept;
 
   /// \brief The template argument list used to specialize the concept.
   TemplateArgumentList *TemplateArgs;
   TemplateArgumentListInfo TemplateArgInfo;
 
   /// \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, and updates the IsSatisfied field. Returns true
-  /// if an error occured and the concept could not be checked for satisfaction.
-  bool calculateSatisfaction(Sema &S);
+  /// \brief The concept's constraint expression with the template arguments
+  /// substituted in for use in diagnostics and normalization. If the
+  /// substituted expression was ill-formed, this will store diagnostic
+  /// explaining why it was so. If the template arguments could not be
+  /// substituted into the constraint expression, this will be null.
+  ///
+  /// This may still contain a substituted constraint exception even if the
+  /// expression is dependent (but this is not always the case).
+  llvm::PointerUnion<Expr *, SubstitutionDiagnostic *>
+      SubstitutedConstraintExpr;
 
 public:
   ConceptSpecializationExpr(ASTContext &C, Sema &S,
                             SourceLocation ConceptNameLoc, ConceptDecl *CD,
                             const TemplateArgumentListInfo *TALI);
 
   ConceptSpecializationExpr(ASTContext &C, EmptyShell Empty);
 
assert(!isValueDependent()
            && "isSatisfied called on a dependent ConceptSpecializationExpr");
     return IsSatisfied;
   }
 
   void setSatisfied(bool Satisfied) {
     IsSatisfied = Satisfied;
   }
 
+  Expr *getSubstitutedConstraintExpr() const {
+    return SubstitutedConstraintExpr.dyn_cast<Expr *>();
+  }
+
+  void setSubstitutedConstraintExpr(Expr *SCE) {
+    SubstitutedConstraintExpr = SCE;
+  }
+
+  const SubstitutionDiagnostic *getSubstitutionDiagnostic() const {
+    return SubstitutedConstraintExpr.dyn_cast<SubstitutionDiagnostic*>();
+  }
+
+  void setSubstitutionDiagnostic(SubstitutionDiagnostic *Diag) {
+    SubstitutedConstraintExpr = Diag;
+  }
+
   SourceLocation getConceptNameLoc() const { return ConceptNameLoc; }
     void setConceptNameLoc(SourceLocation Loc) {
     ConceptNameLoc = Loc;
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ConceptSpecializationExprClass;
   }
 
   SourceLocation getLocStart() const LLVM_READONLY { return ConceptNameLoc; }

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">;
+def note_constraints_not_satisfied : Note<
+  "constraints not satisfied">;
+def note_substituted_constraint_expr_is_ill_formed : Note<
+  "because substituted constraint expression is ill-formed%0">;
+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 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,
                                            CXXConversionDecl *Conv,
                                            Expr *Src);
 
   ExprResult
   CreateConceptSpecializationExpr(SourceLocation ConceptNameLoc,
                                   ConceptDecl *CD,
                                   const TemplateArgumentListInfo *TALI);
 
-  /// Check whether the given expression is a valid constraint expression.
-  /// A diagnostic is emitted if it is not, and false is returned.
+  /// \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);
 
+  /// \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(Expr *SubstitutedConstraintExpr);
+
+  /// \brief Emit diagnostics explaining why a constraint expression was deemed
+  /// unsatisfied because it was ill-formed.
+  void DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLocation,
+                                              StringRef Diagnostic);
+  void DiagnoseUnsatisfiedIllFormedConstraint(PartialDiagnosticAt *Diagnostic);
+
   // 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 *"

   ///
   /// \param Converted Will receive the converted, canonicalized template
   /// arguments.
   ///
   /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
   /// contain the converted forms of the template arguments as written.
   /// Otherwise, \p TemplateArgs will not be modified.
   ///
+  /// \param InstantiationDependent If provided, and no error occured, will
+  /// receive true if the arguments' match to the given template is
+  /// instantiation dependant - e.g. the arguments contain a pack expansion
+  /// into a non pack parameter.
+  ///
   /// \returns true if an error occurred, false otherwise.
   bool CheckTemplateArgumentList(TemplateDecl *Template,
                                  SourceLocation TemplateLoc,
                                  TemplateArgumentListInfo &TemplateArgs,
                                  bool PartialTemplateArgs,
                                  SmallVectorImpl<TemplateArgument> &Converted,
-                                 bool UpdateArgsWithConversions = true);
+                                 bool UpdateArgsWithConversions = true,
+                                 bool *InstantiationDependent = nullptr);
 
   bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
                                  TemplateArgumentLoc &Arg,
                            SmallVectorImpl<TemplateArgument> &Converted);
 
   bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
                              TypeSourceInfo *Arg);
   ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
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,
       NamedConcept(CD), ConceptNameLoc(ConceptNameLoc) {
   setTemplateArguments(&S, TALI);
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(ASTContext &C,
                                                      EmptyShell Empty)
   : Expr(ConceptSpecializationExprClass, Empty) { }
 
-bool ConceptSpecializationExpr::calculateSatisfaction(Sema &S)
-{
-  llvm::SmallVector<TemplateArgument, 4> Converted;
-  if (S.CheckTemplateArgumentList(NamedConcept, NamedConcept->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(NamedConcept->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 calculateSatisfaction(*S);
+  if (!S)
+    // The expression is probably being read from a module file.
+    return false;
+
+  llvm::SmallVector<TemplateArgument, 4> Converted;
+  bool InstantiationDependent = false;
+  if (S->CheckTemplateArgumentList(NamedConcept,
+                                   NamedConcept->getLocStart(),
+                                   TemplateArgInfo,
+                                   /*PartialTemplateArgs=*/false, Converted,
+                                   /*UpdateArgsWithConversion=*/false,
+                                   &InstantiationDependent))
+    // We converted these arguments back in CheckConceptTemplateId, this should
+    // work.
+    return true;
+
+  if (InstantiationDependent) {
+    // We can't instantiate the constraint expression now.
+    IsSatisfied = true;
+    return false;
+  }
+
+  ExprResult SubstConstraint;
+  llvm::Optional<PartialDiagnosticAt> SubstDiagnostic;
+  if (S->CheckConstraintSatisfaction(NamedConcept,
+                                     NamedConcept->getConstraintExpr(),
+                                     Converted, ConceptNameLoc, IsSatisfied,
+                                     SubstConstraint, SubstDiagnostic)){
+    S->Diag(getLocStart(), diag::note_in_concept_specialization) << this;
+    return true;
+  }
+  if (!SubstConstraint.isInvalid() && SubstConstraint.isUsable())
+    SubstitutedConstraintExpr = SubstConstraint.get();
+  else if (SubstDiagnostic.hasValue()) {
+    SmallString<128> DiagString;
+    DiagString = ": ";
+    SubstDiagnostic.getValue().second.EmitToString(S->getDiagnostics(),
+                                                   DiagString);
+    SubstitutedConstraintExpr =
+        new (S->Context) SubstitutionDiagnostic{
+            SubstDiagnostic.getValue().first, std::string(DiagString.begin(),
+                                                          DiagString.end()) };
   }
   return false;
 }
 No newline at end of file

lib/Sema/SemaConcept.cpp

 //===-- SemaConcept.cpp - Semantic Analysis for Constraints and Concepts --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ constraints and concepts.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Sema/TemplateDeduction.h"
+#include "clang/Sema/Template.h"
 #include "clang/Sema/SemaInternal.h"
+#include "clang/AST/ExprCXX.h"
 using namespace clang;
 using namespace sema;
 
 bool Sema::CheckConstraintExpression(Expr *ConstraintExpression) {
   // C++2a [temp.constr.atomic]p1
   // ..E shall be a constant expression of type bool.
 
   if (BinaryOperator* BinOp = dyn_cast<BinaryOperator>(ConstraintExpression)) {
bool Sema::CheckRedeclarationConstraintMatch(const Expr *OldAC,
   if (NewAC && OldAC) {
     llvm::FoldingSetNodeID OldACInfo, NewACInfo;
     NewAC->Profile(NewACInfo, Context, /*Canonical=*/true);
     OldAC->Profile(OldACInfo, Context, /*Canonical=*/true);
     if (NewACInfo == OldACInfo)
       return true; // All good; no mismatch.
   }
   return false;
+}
+
+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;
+    if (SubstitutedConstraintExpr.isUsable()) {
+      DiagnoseUnsatisfiedConstraint(SubstitutedConstraintExpr.get());
+    } else {
+      DiagnoseUnsatisfiedIllFormedConstraint(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);
+        BO->getRHS()->EvaluateAsBooleanCondition(Result, S.Context);
+        if (!Result) {
+          // RHS evaluated to false as well - diagnose it too.
+          diagnoseUnsatisfiedConstraintExpr(S, BO->getRHS(), /*First=*/false);
+        }
+        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->getNamedConcept();
+    } else {
+      S.Diag(E->getSourceRange().getBegin(),
+          diag::note_concept_specialization_constraint_evaluated_to_false)
+          << (int)First << E;
+    }
+    if (Expr *Subst = CSE->getSubstitutedConstraintExpr()) {
+      S.DiagnoseUnsatisfiedConstraint(Subst);
+    } else {
+      auto *Diag = CSE->getSubstitutionDiagnostic();
+      assert(Diag && "Unsatisfied constraint expression with no substituted "
+                     "expr nor diagnostic - is it still dependent?");
+      S.DiagnoseUnsatisfiedIllFormedConstraint(Diag->first, Diag->second);
+    }
+    return;
+  }
+  S.Diag(E->getSourceRange().getBegin(),
+         diag::note_atomic_constraint_evaluated_to_false) << (int)First << E;
+}
+
+void Sema::DiagnoseUnsatisfiedConstraint(Expr *UnsatisfiedConstraintExpr) {
+  diagnoseUnsatisfiedConstraintExpr(*this, UnsatisfiedConstraintExpr);
+}
+
+void Sema::DiagnoseUnsatisfiedIllFormedConstraint(PartialDiagnosticAt *PDiag) {
+  if (PDiag) {
+    SmallString<128> SFINAEArgString;
+    SFINAEArgString = ": ";
+    PDiag->second.EmitToString(getDiagnostics(), SFINAEArgString);
+    DiagnoseUnsatisfiedIllFormedConstraint(PDiag->first, SFINAEArgString);
+  } else {
+    DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation(), "");
+  }
+}
+void Sema::DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLoc,
+                                                  StringRef Diagnostic) {
+  Diag(DiagnosticLoc,
+       diag::note_substituted_constraint_expr_is_ill_formed)
+      << Diagnostic;
 }
 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;
if (getLangOpts().CUDA && ConsiderCudaAttrs) {
 
     assert((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target.");
 
     // Allow overloading of functions with same signature and different CUDA
     // target attributes.
     return NewTarget != OldTarget;
   }
 
+  // TODO: Concepts: Check function trailing requires clauses here.
+
   // The signatures match; this is not an overload.
   return false;
 }
 
 /// \brief Checks availability of the function depending on the current
 /// function context. Inside an unavailable function, unavailability is ignored.
 ///
 /// \returns true if \arg FD is unavailable and current context is inside
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;
+
+    if (DeductionFailure.HasDiagnostic) {
+      S.DiagnoseUnsatisfiedIllFormedConstraint(
+                                        DeductionFailure.getSFINAEDiagnostic());
+    } else {
+      S.DiagnoseUnsatisfiedConstraint(
+         static_cast<CNSInfo*>(DeductionFailure.Data)
+             ->SubstitutedConstraintExpr.get());
+    }
+    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.
+  bool InstantiationDependentMatch;
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
-                                false, Converted))
+                                false, Converted,
+                                /*UpdateArgsWithConversion=*/true,
+                                &InstantiationDependentMatch))
+    return QualType();
+
+  if (!InstantiationDependentMatch
+      && 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 for unexpanded parameter packs in any of the template arguments.
   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
     if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                         UPPC_PartialSpecialization))
       return true;
 
   // Check that the template argument list is well-formed for this
   // template.
+  bool InstantiationDependent;
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
-                                false, Converted))
+                                false, Converted,
+                                /*UpdateArgsWithConversion=*/true,
+                                &InstantiationDependent))
+    return true;
+
+  if (!InstantiationDependent
+      && 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;

 
 DeclResult
 Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
                          SourceLocation TemplateNameLoc,
                          const TemplateArgumentListInfo &TemplateArgs) {
   assert(Template && "A variable template id without template?");
 
   // Check that the template argument list is well-formed for this template.
+  bool InstantiationDependentMatch;
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(
           Template, TemplateNameLoc,
           const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
-          Converted))
+          Converted, /*UpdateArgsWithConversion=*/true,
+          &InstantiationDependentMatch))
+    return true;
+
+  if (!InstantiationDependentMatch
+      && 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);
bool DependentArguments =
     TemplateSpecializationType::anyDependentTemplateArguments(
       *TemplateArgs, InstantiationDependent);
   if (R.getAsSingle<VarTemplateDecl>() && !DependentArguments) {
     return CheckVarTemplateId(SS, R.getLookupNameInfo(),
                               R.getAsSingle<VarTemplateDecl>(),
                               TemplateKWLoc, TemplateArgs);
   }
 
-  if (R.getAsSingle<ConceptDecl>() && !DependentArguments) {
+  if (R.getAsSingle<ConceptDecl>()) {
     return CheckConceptTemplateId(SS, R.getLookupNameInfo(),
                                   R.getAsSingle<ConceptDecl>(),
                                   TemplateKWLoc, TemplateArgs);
   }
 
   // We don't want lookup warnings at this point.
   R.suppressDiagnostics();
 

 }
 
 /// \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) {
+    bool UpdateArgsWithConversions, bool *InstantiationDependent) {
+
   // 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.
if (ArgIdx < NumArgs) {
           ArgumentPack.clear();
         }
 
         while (ArgIdx < NumArgs) {
           Converted.push_back(NewArgs[ArgIdx].getArgument());
           ++ArgIdx;
         }
 
+        // We cannot determine yet whether the arguments are well-formed.
+        if (InstantiationDependent)
+          *InstantiationDependent = true;
+
         return false;
       }
 
       continue;
     }
 
     // If we're checking a partial template argument list, we're done.
     if (PartialTemplateArgs) {
       if ((*Param)->isTemplateParameterPack() && !ArgumentPack.empty())
         Converted.push_back(
             TemplateArgument::CreatePackCopy(Context, ArgumentPack));
 
+      if (InstantiationDependent)
+        *InstantiationDependent = false;
       return false;
     }
 
     // If we have a template parameter pack with no more corresponding
     // arguments, just break out now and we'll fill in the argument pack below.
     if ((*Param)->isTemplateParameterPack()) {
       assert(!getExpandedPackSize(*Param) &&
              "Should have dealt with this already");
bool Sema::CheckTemplateArgumentList(
   if (ArgIdx < NumArgs)
     return diagnoseArityMismatch(*this, Template, TemplateLoc, NewArgs);
 
   // No problems found with the new argument list, propagate changes back
   // to caller.
   if (UpdateArgsWithConversions)
     TemplateArgs = std::move(NewArgs);
 
+  if (InstantiationDependent)
+    *InstantiationDependent = false;
+
   return false;
 }
 
 namespace {
   class UnnamedLocalNoLinkageFinder
     : public TypeVisitor<UnnamedLocalNoLinkageFinder, bool>
   {
     Sema &S;
Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec,
   // Check for unexpanded parameter packs in any of the template arguments.
   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
     if (DiagnoseUnexpandedParameterPack(TemplateArgs[I],
                                         UPPC_PartialSpecialization))
       return true;
 
   // Check that the template argument list is well-formed for this
   // template.
+  bool InstantiationDependent;
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
-                                TemplateArgs, false, Converted))
+                                TemplateArgs, false, Converted,
+                                /*UpdateArgsWithConversion=*/true,
+                                &InstantiationDependent))
+    return true;
+
+  if (!InstantiationDependent
+      && 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;
Sema::ActOnExplicitInstantiation(Scope *S,
   }
 
   // Translate the parser's template argument list in our AST format.
   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 
   // Check that the template argument list is well-formed for this
   // template.
+  bool InstantiationDependent;
   SmallVector<TemplateArgument, 4> Converted;
   if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc,
-                                TemplateArgs, false, Converted))
+                                TemplateArgs, false, Converted,
+                                /*UpdateArgsWithConversion=*/true,
+                                &InstantiationDependent))
+    return true;
+
+  if (!InstantiationDependent
+      && 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

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(
   for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
     ArgLocs.push_back(Loc.getArgLoc(I));
   if (SemaRef.Subst(ArgLocs.data(), ArgLocs.size(),
                     InstTemplateArgs, TemplateArgs))
     return nullptr;
 
   // Check that the template argument list is well-formed for this
   // class template.
+  bool InstantiationDependent;
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
                                         D->getLocation(),
                                         InstTemplateArgs,
                                         false,
-                                        Converted))
+                                        Converted,
+                                        /*UpdateArgsWithConversion=*/true,
+                                        &InstantiationDependent))
+    return nullptr;
+
+  if (!InstantiationDependent
+      && 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);
 
Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
   VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo.getLAngleLoc());
   VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo.getRAngleLoc());
 
   if (SemaRef.Subst(TemplateArgsInfo.getArgumentArray(),
                     TemplateArgsInfo.size(), VarTemplateArgsInfo, TemplateArgs))
     return nullptr;
 
   // Check that the template argument list is well-formed for this template.
+  bool InstantiationDependent;
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(
           VarTemplate, VarTemplate->getLocStart(),
           const_cast<TemplateArgumentListInfo &>(VarTemplateArgsInfo), false,
-          Converted))
+          Converted, /*UpdateArgsWithConversion=*/true,
+          &InstantiationDependent))
+    return nullptr;
+
+  if (!InstantiationDependent
+      && 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.

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);
+  if (Record.readInt()) {
+    E->setSubstitutedConstraintExpr(Record.readExpr());
+  } else {
+    SourceLocation DiagLocation = Record.readSourceLocation();
+    std::string DiagMessage = Record.readString();
+    E->setSubstitutionDiagnostic(
+        new (Record.getContext())
+            ConceptSpecializationExpr::SubstitutionDiagnostic{DiagLocation,
+                                                              DiagMessage});
+  }
 }
 
 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());
+  Expr *SubstitutedExpr = E->getSubstitutedConstraintExpr();
+  Record.push_back(SubstitutedExpr != nullptr);
+  if (SubstitutedExpr) {
+    Record.AddStmt(SubstitutedExpr);
+  } else {
+    auto *SubstitutionDiagnostic = E->getSubstitutionDiagnostic();
+    Record.AddSourceLocation(SubstitutionDiagnostic->first);
+    Record.AddString(SubstitutionDiagnostic->second);
+  }
   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 bool X = 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>

 concept IsTypePredicate = is_same_v<decltype(P<bool>::value), const bool>
                           && is_same_v<decltype(P<int>::value), const bool>
                           && is_same_v<decltype(P<long long>::value), const bool>;
 
 template<typename T> struct T1 {};
 template<typename T> struct T2 { static constexpr bool value = sizeof(T) == 2; };
 
 static_assert(IsTypePredicate<T2>);
-static_assert(!IsTypePredicate<T1>);
+static_assert(!IsTypePredicate<T1>);
+
+template<typename T, typename U, typename... Ts>
+concept OneOf = (Same<T, Ts> || ...);
+
+template<typename... X>
+constexpr bool S = OneOf<X..., int, int>;
+
+static_assert(S<int, long, int>);
+static_assert(!S<long, int, char, char>);
 No newline at end of file

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 {{because 'is_ptr_v<int>' evaluated to false}} expected-note {{because '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{{because '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]}}
+
+template<typename T, typename U>
+  requires sizeof(T) != sizeof(U) // expected-note{{because 'sizeof(int) != sizeof(char [4])' (4 != 4) evaluated to false}}
+           && sizeof(T) >= 4 // expected-note{{because '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]]}}
+static_assert(SizeDiff<char, int> == 3); // expected-error{{constraints not satisfied for variable template 'SizeDiff' [with T = char, U = int]}}
+
+template<typename... Ts>
+  requires ((sizeof(Ts) == 4) || ...) // expected-note{{because '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]>]}}
+
+template<typename T>
+concept IsBig = sizeof(T) > 100; // expected-note{{because 'sizeof(int) > 100' (4 > 100) evaluated to false}}
+
+template<typename T>
+  requires IsBig<T> // expected-note{{'int' does not satisfy 'IsBig'}}
+using BigPtr = T*;
+
+static_assert(sizeof(BigPtr<int>)); // expected-error{{constraints not satisfied for alias template 'BigPtr' [with T = int]}}}}
+
+template<typename T> requires T::value // expected-note{{because 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]}}
+static_assert(S<S2>::value);
+
+template<typename T>
+struct AA
+{
+    template<typename U> requires sizeof(U) == sizeof(T) // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4) evaluated to false}}
+    struct B
+    {
+        static constexpr int a = 0;
+    };
+
+    template<typename U> requires sizeof(U) == sizeof(T) // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4) evaluated to false}}
+    static constexpr int b = 1;
+
+    template<typename U> requires sizeof(U) == sizeof(T) // expected-note{{because 'sizeof(int [2]) == sizeof(int)' (8 == 4) evaluated to false}}
+    static constexpr int getB() { // expected-note{{candidate template ignored: constraints not satisfied [with U = int [2]]}}
+        return 2;
+    }
+
+    static auto foo()
+    {
+        return B<T[2]>::a; // expected-error{{constraints not satisfied for class template 'B' [with U = int [2]]}}
+    }
+
+    static auto foo1()
+    {
+        return b<T[2]>; // expected-error{{constraints not satisfied for variable template 'b' [with U = int [2]]}}
+    }
+
+    static auto foo2()
+    {
+        return AA<T>::getB<T[2]>(); // expected-error{{no matching function for call to 'getB'}}
+    }
+};
+
+constexpr auto x = AA<int>::foo(); // expected-note{{in instantiation of member function 'AA<int>::foo' requested here}}
+constexpr auto x1 = AA<int>::foo1(); // expected-note{{in instantiation of member function 'AA<int>::foo1' requested here}}
+constexpr auto x2 = AA<int>::foo2(); // expected-note{{in instantiation of member function 'AA<int>::foo2' requested here}}
 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 {{because '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]}}
+}
+
+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