[Concepts] Requires Expressions

[saar.raz]

Summary

Implement the requires expression. Depends on D44352.

[saar.raz]

• Deal with cases where substitution fails but no diagnostic is available

[saar.raz]

• Predefine __cpp_concepts when supported

[saar.raz]

• Rebase onto trunk
• Fixed ignoring of ScopeSpecifier in constrained parameter in compound requirements
• Fixed incorrect substitution and type deduction into constrained parameter return type requirement (depth was not being considered)
• Fix incorrect check for unevaluated context for requires expr local parameters.
• Added short-circuiting to the substitution-satisfaction check
• Disallow plain 'auto' in return type requirement
• Fixed bug where diagnosed but successful substitution would count as valid
• Add non-SFINAE CodeSynthesisContext to nested requirement constraints check
• Remove a shortcut 'if' in compound requirements which was non-conforming
• Split requires expr parameter and body scopes
• Add missing CorrectDelayedTyposInExpr
• Add RequiresBodyDecl to switch where it was missing
• Predefine __cpp_concepts when concepts are activated
• Deal with cases where substitution failed but no diagnostic is available

[saar.raz]

• Remove #ifs from test
• Updated test diagnostics

[riccibruno]

include/clang/AST/ExprCXX.h

4515

You can stash these in the bit-field classes of Stmt to save some space.

4518

Can you tail-allocate them ?

4547

If in general you don't strictly need to modify some internal state of an AST node, I think it would be better to not provide the corresponding method.

4559

LLVM_READONLY is pointless here.

4566

You should also provide the const-qualified version.

[saar.raz]

Remove outdated grammar support in return-type-requirements, removing some hacks and simplifying the code.

[rsmith]

include/clang/AST/DeclCXX.h

1967

The semicolon here is in the wrong place (should be before the final }, not after).

include/clang/AST/DeclTemplate.h

1185 ↗

(On Diff #203713)

Please move this bugfix earlier in the patch series.

include/clang/AST/ExprCXX.h

4518

Using a SmallVector here is a bug; the destructor is not run on Expr nodes so this will leak memory. Please do change to using tail allocation here.

4519

Reorder this next to RequiresKWLoc. SourceLocations are 4 bytes, whereas for most platforms we care about, pointers are size-8 and align-8, so the reordering will save 8 bytes of padding.

4530

Please avoid adding setters to Expr subclasses if possible. We want the AST to be immutable. (Befriend ASTReaderStmt instead.)

include/clang/Basic/DiagnosticParseKinds.td

688

. Did -> ; did so this fits the general diagnostic pattern regardless of whether the diagnostic renderer capitalizes the diagnostic.

689

Move ? to the end.

lib/AST/ExprCXX.cpp

33–37

These #includes are all unacceptable. AST is layered below Sema, and cannot depend on Sema headers and classes.

lib/AST/ExprConstant.cpp

9091–9093

It is a logic error for the expression evaluator to encounter a value-dependent expression, and we assert on the way into the evaluator if we would encounter one. You don't need to check this here.

lib/AST/StmtProfile.cpp

1264

We don't /need to/ profile isSimple, but we still could. (This "is equivalent to" doesn't override the general ODR requirement that you spell the expression with the same token sequence.)

Do we mangle simple and compound requirements the same way? (Has a mangling for requires-expressions even been proposed on the Itanium ABI list yet?)

lib/Parse/ParseExprCXX.cpp

3009

Recovering by producing an (always-satisfied) RequiresExpr with no requirements would seem reasonable here.

3025

This is incorrect. A simple-requirement can begin with the typename keyword. (Eg, requires { typename T::type() + 1; })

The right way to handle this is to call TryAnnotateTypeOrScopeToken() when you see tok::kw_typename, and then detect a type-requirement as a tok::annot_typename followed by a tok::semi. (By following that approach, you can also handle cases where the typename is missing.) You'll need to deal specially with the case where the nested-name-specifier is omitted, since in that case the typename keyword does not form part of a typename-specifier; in that case, after TryAnnotateTypeOrScopeToken() you'll have a tok::kw_typename, tok::identifier, tok::semi sequence or a tok::kw_typename, tok::annot_template_id, tok::semi sequence to detect and special-case.

3037

Do we need to skip the entirety of the requires-expression in this case? Skipping to the semicolon would seem sufficient, and would allow us to recover better.

3211

You need to distinguish between a simple-requirement and a nested-requirement here. requires { requires { 0; }; }; is valid and has a requires-expression as a simple-requirement. (We should issue a warning on such cases, since only the validity of the requires-expression is checked -- and it's always valid -- and its result is ignored. But we should at least parse it properly.)

This might need unbounded lookahead. Eg, consider requires { requires (A<T1, T2, T3> && B): if the next token is {, it's a requires-expression in a simple-requirement. Otherwise, it's a nested-requirement. In general, I think this is correct:

• If the token after requires is {, we have a requires-expression in a simple-requirement.
• If the token after requires is (, skip to the matching ); if the next token is {, we have a requires-expression in a simple-requirement.
• In all other cases, we have a nested-requirement.

You can optimize the second bullet by tentatively parsing a function parameter list (TryParseFunctionDeclarator) rather than just skipping to the ); that will often let us determine that we have a nested-requirement by inspecting fewer tokens. (And hopefully in the common case we can just see that the parenthesized tokens begin with a template-id naming a concept, so we can't possibly have a function parameter list.)

lib/Sema/SemaExpr.cpp

1644

(Unused.)

lib/Sema/SemaTemplateInstantiate.cpp

937–968

Do we really need to duplicate the TreeTransform code here, and add a representation for a requirement whose substitution failed, and so on?

Possible alternative: create a SFINAETrap for the entire requires-expression, perform a TreeTransform of the whole thing, and if it fails, capture the diagnostic and build a FailedRequiresExpr node that stores the diagnostic and evaluates to false. (Under this model, a non-value-dependent RequiresExpr would always evaluate to true.) That should simplify this code, and the representations of RequiresExpr and Requirements (since you don't need to model "substitution failed" any more, nor conditionally store a diagnostic on a requirement).

Are there cases where we want to retain more information than that? (I don't think there are, since you don't actually retain any useful information from the requirement that failed, other than the diagnostic itself, but maybe I've missed something.) The results of a successful substitution into some parts of a failed RequiresExpr don't really seem interesting.

944

Typo Satisfcation -> Satisfaction

lib/Serialization/ASTWriterStmt.cpp

15

Don't use angled includes to find Clang headers. (Also, the use of this header here is deeply suspicious: this header describes an interface between Sema and the Parser that Serialization should generally not need to know about.)

[saar.raz]

Ignore RequiresExprBodyDecl when looking for function level decl context

[saar.raz]

Adjusted to changes in previous patches

[saar.raz]

Address some CR comments

[saar.raz]

lib/AST/StmtProfile.cpp

1264

Not yet :(

[saar.raz]

Address final CR comments, add PCH tests

[saar.raz]

lib/Sema/SemaTemplateInstantiate.cpp

937–968

Wouldn't it be interesting to store the successful requirements prior to the failed ones? I imagine some tools might want this information

[saar.raz]

Refactor Requirement and subclasses to the AST, extract their creation logic to Sema.

[rsmith]

(Partial comments; I'll try to complete the review today or tomorrow.)

clang/include/clang/AST/ExprCXX.h

4933 ↗

(On Diff #236687)

You're adding a total of ~400 lines here; that seems sufficient to factor out into a separate header (ExprConcepts.h, containing this and ConceptSpecializationExpr maybe?)

4936 ↗

(On Diff #236687)

This name (clang::Requirement) is a little too general for my tastes; consider moving these to a sub-namespace.

clang/include/clang/AST/RecursiveASTVisitor.h

2714–2716 ↗

(On Diff #236687)

We should traverse the entire type-constraint here, including the nested name specifier and concept name.

clang/include/clang/Basic/DiagnosticParseKinds.td

766 ↗

(On Diff #236687)

requirements -> requirement

774 ↗

(On Diff #236687)

Missing ? somewhere in this diagnostic, I think.

clang/include/clang/Basic/DiagnosticSemaKinds.td

2638 ↗

(On Diff #236687)

" and not" -> ", not"

would be a bit more consistent with how we phrase similar things elsewhere.

clang/include/clang/Sema/Sema.h

6285 ↗

(On Diff #236687)

& on the right, please (here and below).

clang/lib/AST/ExprCXX.cpp

1848–1855 ↗

(On Diff #236687)

This representation for a type-constraint seems a bit surprising. Do we really need the template parameter + template parameter list here? It seems to me like we should only really need the TypeConstraint itself, plus its immediately-declared constraint.

[saar.raz]

Address first round of CR comments

[saar.raz]

Addressed comments in latest diff.

clang/include/clang/AST/RecursiveASTVisitor.h

2714–2716 ↗

(On Diff #236687)

We are traversing all that down the line when traversing the actual template type parameter.

[rsmith]

clang/lib/AST/StmtPrinter.cpp

2296 ↗

(On Diff #236687)

I can see why this is the most straightforward way to implement this, but ... yuck. Please add a FIXME :)

clang/lib/AST/StmtProfile.cpp

1363 ↗

(On Diff #236687)

This means "equivalent to" in the plain English sense, not in the [temp.over.link] sense, and in any case is not normative. The normative rule is the one in [temp.over.link] based on the ODR / token sequence. It'd be fine to profile isSimple() if you want to. (But it's not necessary since a { expr }; requirement is functionally equivalent to a expr; requirement.)

[rsmith]

clang/include/clang/AST/ExprConcepts.h

144–148 ↗

(On Diff #238349)

Please add a FIXME to store the diagnostic semantically rather than as a pre-rendered string.

clang/lib/Parse/ParseExprCXX.cpp

3345 ↗

(On Diff #238349)

Please call these ActOnStart... and ActOnFinish... for consistency with other such functions in Sema.

3348 ↗

(On Diff #238349)

This if body is long (even though it's just one statement); please add braces here.

3392 ↗

(On Diff #238349)

him -> them, and please add a period.

3447 ↗

(On Diff #238349)

Please add a FIXME to avoid walking these tokens twice (once in TryParseParameterDeclarationClause and again here).

3504–3513 ↗

(On Diff #238349)

Doing this by messing with the token stream and trying to perform annotation twice seems quite unclean, and you're doing too much of the semantic work of interpreting the typename requirement from inside the parser. Here's what I'd suggest:

First, call TryAnnotateCXXScopeToken(), which will annotate a scope and a following template-id (if any)

If we then have

• optionally, an annot_cxxscope, then
• an identifier or an annot_template_id, then
• a semi (or, not an l_brace nor an l_paren, depending on how you want to recover from errors)

then we have a typename-requirement. Call Sema::ActOnTypeRequirement and pass in the information you have (a scope and an identifier or template-id), and build a suitable type representation from Sema. (You might want to always build an ElaboratedType with ETK_Typename, even if the nested name specifier is non-dependent, to match the source syntax.)

And do this all in a tentative parse action, so you can revert it to put the typename keyword back when you find out that this is actually a simple-requirement.

3557 ↗

(On Diff #238349)

Is it useful to suggest a compound-requirement here? I expect this'll be hit a lot more for normal typos in the expression (eg, missing semicolon, forgotten operator, etc) than in cases where a compound-requirement was intended. ExpectAndConsumeSemi has various tricks to diagnose these cases well, and should be expected to gain more such tricks in the future; you should just call it here unless you're confident you know what the user did wrong (eg, in the noexcept case).

3574 ↗

(On Diff #238349)

he -> they

3582 ↗

(On Diff #238349)

This should be called ActOn... not Create....

clang/lib/Sema/SemaConcept.cpp

402 ↗

(On Diff #238349)

Please don't use auto here; the type is not clear from context.

964–968 ↗

(On Diff #238349)

Please move this long comment to the previous line. Long trailing comments are a pain to work with and harder to read.

clang/lib/Sema/SemaExpr.cpp

353–354 ↗

(On Diff #238349)

Please make sure you have a test for this in the typeid case (which we parse as unevaluated and then might transform to potentially-evaluated if the operand is an lvalue of polymorphic class type), eg:

class X { virtual ~X(); };
requires (X &x) { static_cast<int(*)[(typeid(x), 0)]>(nullptr); }

clang/lib/Sema/SemaExprCXX.cpp

8290–8293 ↗

(On Diff #238349)

I'm surprised this is necessary; do we not already check for redefinition when building the ParmVarDecl and pushing it into scope?

clang/lib/Sema/TreeTransform.h

11275–11277 ↗

(On Diff #238349)

Add braces here please.

[saar.raz]

Address CR comments.

[saar.raz]

Addressed comments in latest diff.

[rsmith]

clang/include/clang/Parse/Parser.h

804–807 ↗

(On Diff #238411)

Looks like the flag you're adding here is never actually used any more. Please remove it again.

clang/lib/AST/StmtPrinter.cpp

2296 ↗

(On Diff #236687)

I think you've actually fixed this now: we always build a typename type, so never need to print an extra typename here.

clang/lib/Sema/SemaExprCXX.cpp

8291–8292 ↗

(On Diff #238411)

This variable is now unused; please remove it.

8309 ↗

(On Diff #238411)

If we only do this now, do we properly handle requires (int x, decltype(x) y)? (Or is that handled in a separate function prototype scope which we've already left?)

clang/lib/Sema/SemaTemplate.cpp

10259–10261 ↗

(On Diff #238411)

Minor cleanup: I don't think we can ever reasonably get here for enable_if<...>::type with no Ctx. I mean, it's possible, but only from lexically within the definition of enable_if itself (or possibly a class derived from it?), and that's really not worth checking for. We could just skip calling isEnableIf and this whole if block if we don't have a Ctx.

[thakis]

This breaks tests on non-Win, see e.g. http://45.33.8.238/linux/7846/step_7.txt http://45.33.8.238/mac/6120/step_7.txt

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

Please take a look, and if the fix isn't obvious please revert while you investigate.

[thakis]

Doesn't this still break check-clang everywhere? See e.g. http://45.33.8.238/linux/7860/step_7.txt

[thakis]

In D50360#1828329, @thakis wrote:

Doesn't this still break check-clang everywhere? See e.g. http://45.33.8.238/linux/7860/step_7.txt

It looks like this is some incremental build issue; after a clean build everything's happy. I'll see if I can repro which sequence of builds gets me in the bad state, but it's possibly unrelated to this CL. If that changes, I'll comment here again.

[thakis]

I figured out the incremental build test problem, see D73202.

include/clang/AST/DeclCXX.h

public:
 
   bool isCopyDeductionCandidate() const { return IsCopyDeductionCandidate; }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == CXXDeductionGuide; }
 };
 
+/// \brief Represents the body of a requires-expression.
+///
+/// This decl exists merely to serve as the DeclContext for the local
+/// parameters of the requires expression as well as other declarations inside
+/// it.
+///
+/// \code
+/// template<typename T> requires requires (T t) { {t++} -> Regular };
+/// \endcode
+///
+/// In this example, a RequiresExpr object will be generated for the expression,
+/// and a RequiresExprBodyDecl will be created to hold the parameter t and the
+/// template argument list imposed by the compound requirement.
+class RequiresExprBodyDecl : public Decl, public DeclContext {
+  RequiresExprBodyDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
+      : Decl(RequiresExprBody, DC, StartLoc), DeclContext(RequiresExprBody) {}
+
+public:
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+
+  static RequiresExprBodyDecl *Create(ASTContext &C, DeclContext *DC,
+                                      SourceLocation StartLoc);
+
+  static RequiresExprBodyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == RequiresExprBody; }
+};
+
 /// \brief Represents a static or instance method of a struct/union/class.
 ///
 /// In the terminology of the C++ Standard, these are the (static and
 /// non-static) member functions, whether virtual or not.
 class CXXMethodDecl : public FunctionDecl {
   void anchor() override;
 
 protected:

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;
   const ASTTemplateArgumentListInfo *TemplateArgInfo;
 
public:
   }
 
   // Iterators
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
 };
 
+/// C++2a [expr.prim.req]:
+///     A requires-expression provides a concise way to express requirements on
+///     template arguments. A requirement is one that can be checked by name
+///     lookup (6.4) or by checking properties of types and expressions.
+///     [...]
+///     A requires-expression is a prvalue of type bool [...]
+class RequiresExpr final : public Expr {
+  bool IsSatisfied;
+  SourceLocation RequiresKWLoc;
+  RequiresExprBodyDecl *Body;
+  llvm::SmallVector<ParmVarDecl *, 2> LocalParameters;
+  llvm::SmallVector<Requirement *, 3> Requirements;
+  SourceLocation RBraceLoc;
+
+public:
+  RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
+               RequiresExprBodyDecl *Body,
+               ArrayRef<ParmVarDecl *> LocalParameters,
+               ArrayRef<Requirement *> Requirements,
+               SourceLocation RBraceLoc);
+  RequiresExpr(ASTContext &C, EmptyShell Empty) :
+    RequiresExpr(C, SourceLocation(), nullptr, {}, {}, SourceLocation()) {}
+
+  void setLocalParameters(ArrayRef<ParmVarDecl *> LocalParameters);
+  ArrayRef<ParmVarDecl *> getLocalParameters() const { return LocalParameters; }
+
+  void setBody(RequiresExprBodyDecl *Body) { this->Body = Body; }
+  const RequiresExprBodyDecl *getBody() const { return Body; }
+  RequiresExprBodyDecl *getBody() { return Body; }
+
+  void setRequirements(ArrayRef<Requirement *> Requirements);
+  ArrayRef<Requirement *> getRequirements() const { return Requirements; }
+
+  /// \brief Whether or not the requires clause is satisfied.
+  /// The expression must not be dependent.
+  bool isSatisfied() const {
+    assert(!isValueDependent()
+           && "isSatisfied called on a dependent RequiresExpr");
+    return IsSatisfied;
+  }
+
+  SourceLocation getRequiresKWLoc() const { return RequiresKWLoc; }
+  void setRequiresKWLoc(SourceLocation Loc) { RequiresKWLoc = Loc; }
+
+  SourceLocation getRBraceLoc() const { return RBraceLoc; }
+  void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == RequiresExprClass;
+  }
+
+  SourceLocation getLocStart() const LLVM_READONLY { return RequiresKWLoc; }
+  SourceLocation getLocEnd() const LLVM_READONLY {
+    return RBraceLoc;
+  }
+
+  // Iterators
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_EXPRCXX_H

include/clang/AST/RecursiveASTVisitor.h

if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() &&
       !D->hasUnparsedDefaultArg())
     TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg()));
 
   if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() &&
       !D->hasUnparsedDefaultArg())
     TRY_TO(TraverseStmt(D->getDefaultArg()));
 })
 
+DEF_TRAVERSE_DECL(RequiresExprBodyDecl, {})
+
 #undef DEF_TRAVERSE_DECL
 
 // ----------------- Stmt traversal -----------------
 //
 // For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating
 // over the children defined in children() (every stmt defines these,
 // though sometimes the range is empty).  Each individual Traverse*
 // method only needs to worry about children other than those.  To see

 })
 
 DEF_TRAVERSE_STMT(ConceptSpecializationExpr, {
   TRY_TO(TraverseTemplateArgumentLocsHelper(
           S->getTemplateArgumentListInfo()->getTemplateArgs(),
           S->getTemplateArgumentListInfo()->NumTemplateArgs));
 })
 
+DEF_TRAVERSE_STMT(RequiresExpr, {
+  TRY_TO(TraverseDecl(S->getBody()));
+  for (ParmVarDecl *Parm : S->getLocalParameters())
+    TRY_TO(TraverseDecl(Parm));
+  for (Requirement *Req : S->getRequirements())
+    if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
+      if (!TypeReq->isSubstitutionFailure())
+        TRY_TO(TraverseTypeLoc(TypeReq->getType()->getTypeLoc()));
+    } else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req)) {
+      if (!ExprReq->isExprSubstitutionFailure())
+        TRY_TO(TraverseStmt(ExprReq->getExpr()));
+      auto &RetReq = ExprReq->getReturnTypeRequirement();
+      if (RetReq.isTrailingReturnType())
+        TRY_TO(TraverseTypeLoc(RetReq.getTrailingReturnTypeExpectedType()
+                                   ->getTypeLoc()));
+      else if (RetReq.isConstrainedParameter()) {
+        TRY_TO(TraverseTemplateParameterListHelper(
+                   RetReq.getConstrainedParamTemplateParameterList()));
+        TRY_TO(TraverseTypeLoc(RetReq.getConstrainedParamExpectedType()
+                                   ->getTypeLoc()));
+      }
+    } else {
+      auto *NestedReq = cast<NestedRequirement>(Req);
+      if (!NestedReq->isSubstitutionFailure())
+        TRY_TO(TraverseStmt(NestedReq->getConstraintExpr()));
+    }
+})
+
 // These literals (all of them) do not need any action.
 DEF_TRAVERSE_STMT(IntegerLiteral, {})
 DEF_TRAVERSE_STMT(CharacterLiteral, {})
 DEF_TRAVERSE_STMT(FloatingLiteral, {})
 DEF_TRAVERSE_STMT(ImaginaryLiteral, {})
 DEF_TRAVERSE_STMT(StringLiteral, {})
 DEF_TRAVERSE_STMT(ObjCStringLiteral, {})
 DEF_TRAVERSE_STMT(ObjCBoxedExpr, {})

include/clang/Basic/DeclNodes.td

 def Friend : Decl;
 def FriendTemplate : Decl;
 def StaticAssert : Decl;
 def Block : Decl<"blocks">, DeclContext;
 def Captured : Decl, DeclContext;
 def ClassScopeFunctionSpecialization : Decl;
 def Import : Decl;
 def OMPThreadPrivate : Decl;
+def RequiresExprBody : Decl, DeclContext;
 def Empty : Decl;
 

include/clang/Basic/DiagnosticParseKinds.td

def err_friend_explicit_instantiation : Error<
   "friend cannot be declared in an explicit instantiation; if this "
   "declaration is meant to be a friend declaration, remove the 'template' keyword">;
 def err_explicit_instantiation_enum : Error<
   "enumerations cannot be explicitly instantiated">;
 def err_expected_template_parameter : Error<"expected template parameter">;
 def err_constrained_parameter_missing_arguments : Error<
   "concept %0 requires more than 1 template argument; provide the remaining "
   "arguments explicitly to use it here">;
+def note_ill_formed_requires_expression_outside_template : Note<
+  "requires expression outside a template declaration may not contain invalid "
+  "types or expressions">;
+def err_empty_requires_expr : Error<
+  "a requires expression must contain at least one requirement">;
+def err_requires_expr_parameter_list_ellipsis : Error<
+  "varargs not allowed in requires expression">;
+def err_requires_expr_type_req_illegal_identifier : Error<
+  "expected identifier or template-id in type requirement">;
+def err_requires_expr_type_req_template_args_on_non_template : Error<
+  "template arguments provided for non-template '%0'">;
+def err_expected_semi_requirement : Error<
+  "expected ';' at end of requirement">;
+def err_requires_expr_missing_arrow : Error<
+  "expected '->' before expression type requirement">;
+def err_requires_expr_simple_requirement_noexcept : Error<
+  "'noexcept' can only be used in a compound requirements (with '{' '}' around "
+  "the expression)">;
+def err_requires_expr_simple_requirement_unexpected_tok : Error<
+  "unexpected %0 after expression. Did you intend to use a compound "
+  "requirement? (with '{' '}' around the expression)">;
+def err_requires_expr_compound_requirement_non_type_concept : Error<
+  "only type concepts can be used to constrain the type of an expression "
+  "(%0 is a %select{template|value}1 concept)">;
 
 def err_missing_dependent_template_keyword : Error<
   "use 'template' keyword to treat '%0' as a dependent template name">;
 def warn_missing_dependent_template_keyword : ExtWarn<
   "use 'template' keyword to treat '%0' as a dependent template name">;
 
 def ext_extern_template : Extension<
   "extern templates are a C++11 extension">, InGroup<CXX11>;

include/clang/Basic/DiagnosticSemaKinds.td

def err_auto_not_allowed : Error<
   "%select{in function prototype"
   "|in non-static struct member|in struct member"
   "|in non-static union member|in union member"
   "|in non-static class member|in interface member"
   "|in exception declaration|in template parameter until C++17|in block literal"
   "|in template argument|in typedef|in type alias|in function return type"
   "|in conversion function type|here|in lambda parameter"
   "|in type allocated by 'new'|in K&R-style function parameter"
-  "|in template parameter|in friend declaration}1">;
+  "|in template parameter|in friend declaration"
+  "|in requires expression parameter}1">;
 def err_dependent_deduced_tst : Error<
   "typename specifier refers to "
   "%select{class template|function template|variable template|alias template|"
   "template template parameter|template}0 member in %1; "
   "argument deduction not allowed here">;
 def err_auto_not_allowed_var_inst : Error<
   "'auto' variable template instantiation is not allowed">;
 def err_auto_var_requires_init : Error<

 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">;
+  "%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">;
+  "%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">;
+  "%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">;
+  "%select{and|because}0 '%1' (%2 %3 %4) evaluated to false">;
 def note_could_not_normalize_argument_substitution_failed : Note<
   "could not substitute template arguments into %0 %1. "
   "Template arguments to a concept specialization expression must be valid "
   "expressions">;
 def note_could_not_normalize_unmatched_argument_list_after_subst : Note<
   "could not substitute template arguments into %0 %1 - the resulting template "
   "argument list does not match the concept's parameter list">;
 def err_constrained_virtual_method : Error<
   "a virtual function must not have a requires clause">;
 def err_reference_to_function_with_unsatisfied_constraints : Error<
   "invalid reference to function %0 - constraints not satisfied">;
+def note_requires_expr_ill_formed_expr : Note<
+  "expression is invalid: %0">;
+def note_requires_expr_no_implicit_conversion : Note<
+  "no implicit conversion exists between expression type %0 and expected type "
+  "%1">;
+def err_requires_expr_local_parameter_default_argument : Error<
+  "default arguments not allowed for parameters of a requires expression">;
+def err_requires_expr_parameter_referenced_in_evaluated_context : Error<
+  "constraint variable %0 cannot be used in an evaluated context">;
+def note_expr_requirement_expr_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid: %2">;
+def note_expr_requirement_noexcept_not_met : Note<
+  "%select{and|because}0 '%1' may throw an exception">;
+def note_expr_requirement_type_requirement_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid: %2">;
+def note_expr_requirement_ambiguous_conversion : Note<
+  "%select{and|because}0 conversion from expression type %1 to required type %2"
+  " is ambiguous">;
+def note_expr_requirement_no_implicit_conversion : Note<
+  "%select{and|because}0 expression type %1 not implicitly convertible to "
+  "required type %2">;
+def note_expr_requirement_deduction_failed : Note<
+  "%select{and|because}0 expression type %1 does not match given pattern '%2'">;
+def note_expr_requirement_constraints_not_satisfied : Note<
+  "%select{and|because}0 type constraint '%1' was not satisfied:">;
+def note_expr_requirement_constraints_not_satisfied_simple : Note<
+  "%select{and|because}0 expression type %1 does not satisfy %2:">;
+def note_type_requirement_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid: %2">;
+def err_type_requirement_non_type_template : Error<
+  "'%0' refers to a %select{class template|function template|"
+  "variable template|alias template|template template parameter|template}1 "
+  "and not a type template">;
+def err_type_requirement_no_such_type : Error<
+  "'%0' does not name a type">;
+def note_nested_requirement_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid: %2">;
+
 
 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_template_enum_def_here : Note<
   "in instantiation of enumeration %q0 requested here">;
 def note_template_nsdmi_here : Note<
   "in instantiation of default member initializer %q0 requested here">;
 def note_template_type_alias_instantiation_here : Note<
   "in instantiation of template type alias %0 requested here">;
 def note_template_exception_spec_instantiation_here : Note<
   "in instantiation of exception specification for %0 requested here">;
+def note_template_requirement_instantiation_here : Note<
+  "in instantiation of requirement here">;
 def warn_var_template_missing : Warning<"instantiation of variable %q0 "
   "required here, but no definition is available">,
   InGroup<UndefinedVarTemplate>;
 def warn_func_template_missing : Warning<"instantiation of function %q0 "
   "required here, but no definition is available">,
   InGroup<UndefinedFuncTemplate>, DefaultIgnore;
 def note_forward_template_decl : Note<
   "forward declaration of template entity is here">;

include/clang/Basic/StmtNodes.td

 // C++ Coroutines TS expressions
 def CoroutineSuspendExpr : DStmt<Expr, 1>;
 def CoawaitExpr : DStmt<CoroutineSuspendExpr>;
 def DependentCoawaitExpr : DStmt<Expr>;
 def CoyieldExpr : DStmt<CoroutineSuspendExpr>;
 
 // C++2a Concepts expressions
 def ConceptSpecializationExpr : DStmt<Expr>;
+def RequiresExpr : DStmt<Expr>;
 
 // Obj-C Expressions.
 def ObjCStringLiteral : DStmt<Expr>;
 def ObjCBoxedExpr : DStmt<Expr>;
 def ObjCArrayLiteral : DStmt<Expr>;
 def ObjCDictionaryLiteral : DStmt<Expr>;
 def ObjCEncodeExpr : DStmt<Expr>;
 def ObjCMessageExpr : DStmt<Expr>;

include/clang/Parse/Parser.h

Sema::ConditionResult ParseCXXCondition(StmtResult *InitStmt,
                                           Sema::ConditionKind CK);
 
   //===--------------------------------------------------------------------===//
   // C++ Coroutines
 
   ExprResult ParseCoyieldExpression();
 
   //===--------------------------------------------------------------------===//
+  // C++ Concepts
+
+  ExprResult ParseRequiresExpression();
+
+  //===--------------------------------------------------------------------===//
   // C99 6.7.8: Initialization.
 
   /// ParseInitializer
   ///       initializer: [C99 6.7.8]
   ///         assignment-expression
   ///         '{' ...
   ExprResult ParseInitializer() {
     if (Tok.isNot(tok::l_brace))
void ParseFunctionDeclarator(Declarator &D,
                                bool RequiresArg = false);
   bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
                          SourceLocation &RefQualifierLoc);
   bool isFunctionDeclaratorIdentifierList();
   void ParseFunctionDeclaratorIdentifierList(
          Declarator &D,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
   void ParseParameterDeclarationClause(
-         Declarator &D,
+         Declarator::TheContext DeclaratorContext,
          ParsedAttributes &attrs,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
          SourceLocation &EllipsisLoc);
   void ParseBracketDeclarator(Declarator &D);
   void ParseMisplacedBracketDeclarator(Declarator &D);
 
   //===--------------------------------------------------------------------===//
   // C++ 7: Declarations [dcl.dcl]
private:
   Decl *ParseTemplateParameter(unsigned Depth, unsigned Position);
   Decl *ParseTypeParameter(unsigned Depth, unsigned Position);
   Decl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
   Decl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
   bool TryParseConstrainedParameter(ConceptDecl *&CD,
                                     SourceLocation &ConceptNameLoc,
                                     TemplateArgumentListInfo &TALI);
   Decl *ParseConstrainedTemplateParameter(unsigned Depth, unsigned Position,
                                           SourceLocation ParamStartLoc,
                                           ConceptDecl *CD,
                                           TemplateArgumentListInfo TALI);
   void DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
                                  SourceLocation CorrectLoc,
                                  bool AlreadyHasEllipsis,
                                  bool IdentifierHasName);
   void DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
                                              Declarator &D);

include/clang/Sema/DeclSpec.h

enum TheContext {
     CXXCatchContext,     // C++ catch exception-declaration
     ObjCCatchContext,    // Objective-C catch exception-declaration
     BlockLiteralContext, // Block literal declarator.
     LambdaExprContext,   // Lambda-expression declarator.
     LambdaExprParameterContext, // Lambda-expression parameter declarator.
     ConversionIdContext, // C++ conversion-type-id.
     TrailingReturnContext, // C++11 trailing-type-specifier.
     TemplateTypeArgContext, // Template type argument.
-    AliasDeclContext,    // C++11 alias-declaration.
-    AliasTemplateContext // C++11 alias-declaration template.
+    AliasDeclContext,     // C++11 alias-declaration.
+    AliasTemplateContext, // C++11 alias-declaration template.
+    RequiresExprContext   // C++2a requires-expression.
   };
 
 private:
   const DeclSpec &DS;
   CXXScopeSpec SS;
   UnqualifiedId Name;
   SourceRange Range;
 
bool mayOmitIdentifier() const {
     case CXXNewContext:
     case CXXCatchContext:
     case ObjCCatchContext:
     case BlockLiteralContext:
     case LambdaExprContext:
     case ConversionIdContext:
     case TemplateTypeArgContext:
     case TrailingReturnContext:
+    case RequiresExprContext:
       return true;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// mayHaveIdentifier - Return true if the identifier is either optional or
   /// required.  This is true for normal declarators and prototypes, but not
   /// typenames.
   bool mayHaveIdentifier() const {
     switch (Context) {
     case FileContext:
     case KNRTypeListContext:
     case MemberContext:
     case BlockContext:
     case ForContext:
     case InitStmtContext:
     case ConditionContext:
     case PrototypeContext:
     case LambdaExprParameterContext:
     case TemplateParamContext:
     case CXXCatchContext:
     case ObjCCatchContext:
+    case RequiresExprContext:
       return true;
 
     case TypeNameContext:
     case FunctionalCastContext:
     case CXXNewContext:
     case AliasDeclContext:
     case AliasTemplateContext:
     case ObjCParameterContext:
bool mayHaveDecompositionDeclarator() const {
     case ForContext:
     case InitStmtContext:
     case ConditionContext:
       return true;
 
     case MemberContext:
     case PrototypeContext:
     case TemplateParamContext:
+    case RequiresExprContext:
       // Maybe one day...
       return false;
 
     // These contexts don't allow any kind of non-abstract declarator.
     case KNRTypeListContext:
     case TypeNameContext:
     case FunctionalCastContext:
     case AliasDeclContext:
bool mayBeFollowedByCXXDirectInit() const {
     case CXXNewContext:
     case AliasDeclContext:
     case AliasTemplateContext:
     case BlockLiteralContext:
     case LambdaExprContext:
     case ConversionIdContext:
     case TemplateTypeArgContext:
     case TrailingReturnContext:
+    case RequiresExprContext:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// isPastIdentifier - Return true if we have parsed beyond the point where
   /// the name would appear. (This may happen even if we haven't actually parsed
   /// a name, perhaps because this context doesn't require one.)
bool isFunctionDeclarationContext() const {
     case CXXNewContext:
     case CXXCatchContext:
     case ObjCCatchContext:
     case BlockLiteralContext:
     case LambdaExprContext:
     case ConversionIdContext:
     case TemplateTypeArgContext:
     case TrailingReturnContext:
+    case RequiresExprContext:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// Determine whether this declaration appears in a context where an
   /// expression could appear.
   bool isExpressionContext() const {
bool isExpressionContext() const {
     case TemplateParamContext:
     case CXXNewContext:
     case CXXCatchContext:
     case ObjCCatchContext:
     case BlockLiteralContext:
     case LambdaExprContext:
     case ConversionIdContext:
     case TrailingReturnContext:
+    case RequiresExprContext:
       return false;
 
     case BlockContext:
     case ForContext:
     case InitStmtContext:
     case ConditionContext:
     case TemplateTypeArgContext:
       return true;

include/clang/Sema/Sema.h

public:
   /// \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.
+  /// \param First whether this is the first time an unsatisfied constraint is
+  /// diagnosed for this error.
   void
-  DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction);
+  DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction,
+                                bool First = true);
 
   /// \brief Emit diagnostics explaining why a constraint expression was deemed
   /// unsatisfied because it was ill-formed.
   void DiagnoseUnsatisfiedIllFormedConstraint(SourceLocation DiagnosticLocation,
                                               StringRef Diagnostic);
 
   void DiagnoseRedeclarationConstraintMismatch(SourceLocation Old,
                                                SourceLocation New);
public:
   getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                   const TemplateArgumentList &Args);
 
   std::string
   getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                   const TemplateArgument *Args,
                                   unsigned NumArgs);
 
-  // Concepts
+  //===--------------------------------------------------------------------===//
+  // C++ Concepts
+  //===--------------------------------------------------------------------===//
   Decl *ActOnConceptDefinition(
       Scope *S,
       MultiTemplateParamsArg TemplateParameterLists,
       IdentifierInfo *Name, SourceLocation L,
       Expr *ConstraintExpr);
 
+  RequiresExprBodyDecl *
+  ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc,
+                         ArrayRef<ParmVarDecl *> LocalParameters,
+                         Scope *LocalParametersScope);
+  void ActOnExitRequiresExpr();
+  Requirement *ActOnSimpleRequirement(Expr *E);
+  Requirement *ActOnTypeRequirement(SourceLocation TypenameKWLoc,
+                                    CXXScopeSpec TypeScope,
+                                    UnqualifiedId &TypeName);
+  Requirement *ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc);
+  Requirement *ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
+                                        TypeSourceInfo *ExpectedType);
+  Requirement *ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
+                                        SourceLocation ConceptNameLoc,
+                                        ConceptDecl *NamedConcept,
+                                        TemplateArgumentListInfo TemplateArgs,
+                                        Declarator &DeducedDeclarator,
+                                        unsigned Depth);
+  Requirement *ActOnNestedRequirement(Expr *Constraint);
+  ExprResult CreateRequiresExpr(SourceLocation RequiresKWLoc,
+                                RequiresExprBodyDecl *Body,
+                                ArrayRef<ParmVarDecl *> LocalParameters,
+                                ArrayRef<Requirement *> Requirements,
+                                SourceLocation ClosingBraceLoc);
+
   //===--------------------------------------------------------------------===//
   // C++ Variadic Templates (C++0x [temp.variadic])
   //===--------------------------------------------------------------------===//
 
   /// Determine whether an unexpanded parameter pack might be permitted in this
   /// location. Useful for error recovery.
   bool isUnexpandedParameterPackPermitted();
 
VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
       VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
 
   bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
                                     sema::TemplateDeductionInfo &Info);
 
   bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
       TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc);
 
+
+  /// \brief Given a template parameter list containing a single type parameter,
+  /// the type of a parameter of a hypothetical function template with the
+  /// given template parameter list, and the argument passed to that function
+  /// template, attempts to deduce the type parameter.
+  QualType matchTypeByDeduction(TemplateParameterList *TemplateParams,
+                                QualType ParamType, Expr *Arg);
+
   void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
                                   bool OnlyDeduced,
                                   unsigned Depth,
                                   llvm::SmallBitVector &Used);
   void MarkDeducedTemplateParameters(
                                   const FunctionTemplateDecl *FunctionTemplate,
                                   llvm::SmallBitVector &Deduced) {
     return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
enum SynthesisKind {
       /// We are checking the validity of a default template argument that
       /// has been used when naming a template-id.
       DefaultTemplateArgumentChecking,
 
       /// We are instantiating the exception specification for a function
       /// template which was deferred until it was needed.
       ExceptionSpecInstantiation,
 
+      /// We are instantiating a requirement of a requires expression.
+      RequirementInstantiation,
+
       /// We are declaring an implicit special member function.
       DeclaringSpecialMember,
 
       /// We are defining a synthesized function (such as a defaulted special
       /// member).
       DefiningSynthesizedFunction,
     } Kind;
 
struct InstantiatingTemplate {
     /// \brief Note that we are checking the default template argument
     /// against the template parameter for a given template-id.
     InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
                           TemplateDecl *Template,
                           NamedDecl *Param,
                           ArrayRef<TemplateArgument> TemplateArgs,
                           SourceRange InstantiationRange);
 
+    /// \brief Note that we are instantiating a requirement of a requires
+    /// expression.
+    InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                          Requirement *Req,
+                          sema::TemplateDeductionInfo &DeductionInfo,
+                          SourceRange InstantiationRange = SourceRange());
 
     /// \brief Note that we have finished instantiating this template.
     void Clear();
 
     ~InstantiatingTemplate() { Clear(); }
 
     /// \brief Determines whether we have exceeded the maximum
     /// recursive template instantiations.

include/clang/Sema/SemaConcept.h

 #define LLVM_CLANG_SEMA_SEMACONCEPTS_H
 #include "clang/AST/Expr.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/SmallVector.h"
 #include <string>
 #include <utility>
 namespace clang {
+class ConceptSpecializationExpr;
 class Sema;
+
 /// \brief The result of a constraint satisfaction check, containing the
 /// necessary information to diagnose an unsatisfied constraint.
 struct ConstraintSatisfaction {
   using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;
   using Detail = llvm::PointerUnion<Expr *, SubstitutionDiagnostic *>;
 
   bool IsSatisfied = false;
 
   /// \brief Pairs of unsatisfied atomic constraint expressions along with the
   /// substituted constraint expr, if the template arguments could be
   /// substituted into them, or a diagnostic if substitution resulted in an
   /// invalid expression.
   llvm::SmallVector<std::pair<const Expr *, Detail>, 4> Details;
 };
 
+/// \brief A static requirement that can be used in a requires-expression to
+/// check properties of types and expression.
+class Requirement {
+public:
+  // Note - simple and compound requirements are both represented by the same
+  // class (ExprRequirement).
+  enum RequirementKind { RK_Type, RK_Simple, RK_Compound, RK_Nested };
+private:
+  const RequirementKind Kind;
+  bool Dependent : 1;
+  bool ContainsUnexpandedParameterPack : 1;
+  bool Satisfied : 1;
+public:
+  struct SubstitutionDiagnostic {
+      std::string SubstitutedEntity;
+      SourceLocation DiagLoc;
+      std::string DiagMessage;
+  };
+
+  Requirement(RequirementKind Kind, bool IsDependent,
+              bool ContainsUnexpandedParameterPack, bool IsSatisfied = true) :
+      Kind(Kind), Dependent(IsDependent),
+      ContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack),
+      Satisfied(IsSatisfied) {}
+
+  RequirementKind getKind() const { return Kind; }
+
+  bool isSatisfied() const {
+    assert(!Dependent &&
+           "isSatisfied can only be called on non-dependent requirements.");
+    return Satisfied;
+  }
+
+  void setSatisfied(bool IsSatisfied) {
+    assert(!Dependent &&
+           "setSatisfied can only be called on non-dependent requirements.");
+    Satisfied = IsSatisfied;
+  }
+
+  void setDependent(bool IsDependent) { Dependent = IsDependent; }
+  bool isDependent() const { return Dependent; }
+
+  void setContainsUnexpandedParameterPack(bool Contains) {
+    ContainsUnexpandedParameterPack = Contains;
+  }
+  bool containsUnexpandedParameterPack() const {
+    return ContainsUnexpandedParameterPack;
+  }
+
+  virtual void Diagnose(Sema &S, bool First) const = 0;
+
+  virtual ~Requirement() = default;
+};
+
+/// \brief A requires-expression requirement which queries the existence of a
+/// type name or type template specialization ('type' requirements).
+class TypeRequirement : public Requirement {
+public:
+  enum SatisfactionStatus {
+      SS_Dependent,
+      SS_SubstitutionFailure,
+      SS_Satisfied
+  };
+private:
+  llvm::PointerUnion<SubstitutionDiagnostic *, TypeSourceInfo *> Value;
+  SatisfactionStatus Status;
+public:
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
+  /// \brief Construct a type requirement from a type. If the given type is not
+  /// dependent, this indicates that the type exists and the requirement will be
+  /// satisfied. Otherwise, the SubstitutionDiagnostic constructor is to be
+  /// used.
+  TypeRequirement(TypeSourceInfo *T);
+
+  /// \brief Construct a type requirement when the nested name specifier is
+  /// invalid due to a bad substitution. The requirement is unsatisfied.
+  TypeRequirement(SubstitutionDiagnostic *Diagnostic) :
+      Requirement(RK_Type, false, false, false), Value(Diagnostic),
+      Status(SS_SubstitutionFailure) {}
+
+  SatisfactionStatus getSatisfactionStatus() const { return Status; }
+  void setSatisfactionStatus(SatisfactionStatus Status) {
+    this->Status = Status;
+  }
+
+  bool isSubstitutionFailure() const {
+    return Status == SS_SubstitutionFailure;
+  }
+  SubstitutionDiagnostic *getSubstitutionDiagnostic() const {
+    assert(Status == SS_SubstitutionFailure &&
+           "Attempted to get substitution diagnostic when there has been no "
+           "substitution failure.");
+    return Value.get<SubstitutionDiagnostic *>();
+  }
+
+  TypeSourceInfo *getType() const {
+    assert(!isSubstitutionFailure() &&
+           "Attempted to get type when there has been a substitution failure.");
+    return Value.get<TypeSourceInfo *>();
+  }
+
+  void Diagnose(Sema &S, bool First) const override;
+
+  static bool classof(const Requirement *R) {
+    return R->getKind() == RK_Type;
+  }
+};
+
+/// \brief A requires-expression requirement which queries the validity and
+/// properties of an expression ('simple' and 'compound' requirements).
+class ExprRequirement : public Requirement {
+public:
+  enum SatisfactionStatus {
+      SS_Dependent,
+      SS_ExprSubstitutionFailure,
+      SS_NoexceptNotMet,
+      SS_TypeRequirementSubstitutionFailure,
+      SS_ImplicitConversionAmbiguous,
+      SS_NoImplicitConversionExists,
+      SS_DeductionFailed,
+      SS_ConstraintsNotSatisfied,
+      SS_Satisfied
+  };
+  class ReturnTypeRequirement {
+      using ConstrainedParam = std::tuple<TypeSourceInfo *,
+                                          TemplateParameterList *,
+                                          ConceptSpecializationExpr *>;
+      bool Dependent : 1;
+      bool ContainsUnexpandedParameterPack : 1;
+      llvm::PointerUnion3<ConstrainedParam *, TypeSourceInfo *,
+                          SubstitutionDiagnostic *> Value;
+  public:
+      friend class ASTStmtReader;
+      friend class ASTStmtWriter;
+
+      /// \brief No return type requirement was specified.
+      ReturnTypeRequirement() : Dependent(false),
+                                ContainsUnexpandedParameterPack(false) {}
+
+      /// \brief A return type requirement was specified but it was a
+      /// substitution failure.
+      ReturnTypeRequirement(SubstitutionDiagnostic *SubstDiag) :
+          Dependent(false), ContainsUnexpandedParameterPack(false),
+          Value(SubstDiag) {}
+
+      /// \brief A 'trailing return type' style return type requirement.
+      ReturnTypeRequirement(ASTContext &C, TypeSourceInfo *ExpectedType);
+
+      /// \brief A 'constrained parameter' style return type requirement.
+      /// \param TPL an invented template parameter list containing a single
+      /// type parameter and a requires clause.
+      /// \param ExpectedType a qualified type referring to the type parameter
+      /// of TPL.
+      ReturnTypeRequirement(ASTContext &C, TemplateParameterList *TPL,
+                            TypeSourceInfo *ExpectedType);
+
+      /// \brief A 'constrained parameter' style return type with
+      /// pre-instantiated constraint expression. Should only be used by
+      /// ASTStmtReader.
+      ReturnTypeRequirement(ASTContext &C, TemplateParameterList *TPL,
+                            TypeSourceInfo *ExpectedType,
+                            ConceptSpecializationExpr *CSE);
+
+      bool isDependent() const { return Dependent; }
+
+      bool containsUnexpandedParameterPack() const {
+        return ContainsUnexpandedParameterPack;
+      }
+
+      bool isEmpty() const { return Value.isNull(); }
+
+      bool isSubstitutionFailure() const {
+        return Value && Value.is<SubstitutionDiagnostic *>();
+      }
+
+      bool isConstrainedParameter() const {
+        return Value && Value.is<ConstrainedParam *>();
+      }
+
+      bool isTrailingReturnType() const {
+        return Value && Value.is<TypeSourceInfo *>();
+      }
+
+      SubstitutionDiagnostic *getSubstitutionDiagnostic() const {
+        assert(isSubstitutionFailure());
+        return Value.get<SubstitutionDiagnostic *>();
+      }
+
+      TypeSourceInfo *getTrailingReturnTypeExpectedType() const {
+        assert(isTrailingReturnType());
+        return Value.get<TypeSourceInfo *>();
+      }
+
+      TypeSourceInfo *getConstrainedParamExpectedType() const {
+        assert(isConstrainedParameter());
+        return std::get<0>(*Value.get<ConstrainedParam *>());
+      }
+
+      TemplateParameterList *getConstrainedParamTemplateParameterList() const {
+        assert(isConstrainedParameter());
+        return std::get<1>(*Value.get<ConstrainedParam *>());
+      }
+
+      ConceptSpecializationExpr *getConstrainedParamConstraintExpr() const {
+        assert(isConstrainedParameter());
+        return std::get<2>(*Value.get<ConstrainedParam *>());
+      }
+
+      SatisfactionStatus calculateSatisfaction(Sema &S, Expr *E);
+  };
+private:
+  llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> Value;
+  SourceLocation NoexceptLoc; // May be empty if noexcept wasn't specified.
+  ReturnTypeRequirement TypeReq;
+  SatisfactionStatus Status;
+public:
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
+  /// \brief Construct a compound requirement, employing semantic analysis to
+  /// determine its satisfaction status.
+  /// \param E the expression which is checked by this requirement.
+  /// \param IsSimple whether this was a simple requirement in source.
+  /// \param NoexceptLoc the location of the noexcept keyword, if it was
+  /// specified, otherwise an empty location.
+  /// \param Req the requirement for the type of the checked expression (omit
+  /// if no requirement was specified).
+  ExprRequirement(Sema &S, Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
+                  ReturnTypeRequirement Req = {});
+
+  /// \brief Construct a compound requirement with a predetermined satisfaction
+  /// status.
+  /// \param E the expression which is checked by this requirement.
+  /// \param IsSimple whether this was a simple requirement in source.
+  /// \param NoexceptLoc the location of the noexcept keyword, if it was
+  /// specified, otherwise an empty location.
+  /// \param Req the requirement for the type of the checked expression.
+  ExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
+                  ReturnTypeRequirement Req, SatisfactionStatus Status);
+
+  /// \brief Construct a compound requirement whose expression was a
+  /// substitution failure. The requirement is not satisfied.
+  /// \param E the diagnostic emitted while instantiating the original
+  /// expression.
+  /// \param IsSimple whether this was a simple requirement in source.
+  /// \param NoexceptLoc the location of the noexcept keyword, if it was
+  /// specified, otherwise an empty location.
+  /// \param Req the requirement for the type of the checked expression (omit
+  /// if no requirement was specified).
+  ExprRequirement(SubstitutionDiagnostic *E, bool IsSimple,
+                  SourceLocation NoexceptLoc, ReturnTypeRequirement Req = {});
+
+  bool isSimple() const { return getKind() == RK_Simple; }
+  bool isCompound() const { return getKind() == RK_Compound; }
+
+  bool hasNoexceptRequirement() const { return NoexceptLoc.isValid(); }
+  SourceLocation getNoexceptLoc() const { return NoexceptLoc; }
+
+  SatisfactionStatus getSatisfactionStatus() const { return Status; }
+
+  bool isExprSubstitutionFailure() const {
+    return Status == SS_ExprSubstitutionFailure;
+  }
+
+  const ReturnTypeRequirement &getReturnTypeRequirement() const {
+    return TypeReq;
+  }
+
+  SubstitutionDiagnostic *getExprSubstitutionDiagnostic() const {
+    assert(isExprSubstitutionFailure() &&
+           "Attempted to get expression substitution diagnostic when there has "
+           "been no expression substitution failure");
+    return Value.get<SubstitutionDiagnostic *>();
+  }
+
+  Expr *getExpr() const {
+    assert(!isExprSubstitutionFailure() &&
+           "ExprRequirement has no expression because there has been a "
+           "substitution failure.");
+    return Value.get<Expr *>();
+  }
+
+  void Diagnose(Sema &S, bool First) const override;
+
+  static bool classof(const Requirement *R) {
+    return R->getKind() == RK_Compound || R->getKind() == RK_Simple;
+  }
+};
+
+/// \brief A requires-expression requirement which is satisfied when a general
+/// constraint expression is satisfied ('nested' requirements).
+class NestedRequirement : public Requirement {
+  llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> Value;
+  ConstraintSatisfaction Satisfaction;
+
+public:
+  friend class ASTStmtReader;
+  friend class ASTStmtWriter;
+
+  NestedRequirement(SubstitutionDiagnostic *SubstDiag) :
+      Requirement(RK_Nested, /*Dependent=*/false,
+                  /*ContainsUnexpandedParameterPack*/false,
+                  /*Satisfied=*/false), Value(SubstDiag) {}
+
+  NestedRequirement(Expr *Constraint) :
+      Requirement(RK_Nested, /*Dependent=*/true,
+                  Constraint->containsUnexpandedParameterPack()),
+      Value(Constraint) {
+    assert(Constraint->isInstantiationDependent() &&
+           "Nested requirement with Non-dependent constraint must be "
+           "constructed with a Sema& or a ConstraintSatisfaction object");
+  }
+  NestedRequirement(Sema &S, Expr *Constraint);
+  NestedRequirement(Expr *Constraint, ConstraintSatisfaction Satisfaction) :
+      Requirement(RK_Nested, false, false, Satisfaction.IsSatisfied),
+      Value(Constraint), Satisfaction(std::move(Satisfaction)) {}
+
+  bool isSubstitutionFailure() const {
+    return Value.is<SubstitutionDiagnostic *>();
+  }
+  SubstitutionDiagnostic *getSubstitutionDiagnostic() const {
+    assert(isSubstitutionFailure() &&
+           "getSubstitutionDiagnostic() may not be called when there was no "
+           "substitution failure.");
+    return Value.get<SubstitutionDiagnostic *>();
+  }
+
+  Expr *getConstraintExpr() const {
+    assert(!isSubstitutionFailure() && "getConstraintExpr() may not be called "
+                                       "on nested requirements with "
+                                       "substitution failures.");
+    return Value.get<Expr *>();
+  }
+
+  void Diagnose(Sema &S, bool First) const override;
+
+  static bool classof(const Requirement *R) {
+    return R->getKind() == RK_Nested;
+  }
+};
+
 } // clang
 
 #endif
 No newline at end of file

include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_PACK_EXPANSION,        // PackExpansionExpr
       EXPR_SIZEOF_PACK,           // SizeOfPackExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM, // SubstNonTypeTemplateParmExpr
       EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,// SubstNonTypeTemplateParmPackExpr
       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
       EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
+      EXPR_REQUIRES,              // RequiresExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr      
 
       // OpenCL
       EXPR_ASTYPE,                 // AsTypeExpr
 
       // Microsoft

lib/AST/DeclBase.cpp

switch (DeclKind) {
     case VarTemplatePartialSpecialization:
     case ObjCImplementation:
     case ObjCCategory:
     case ObjCCategoryImpl:
     case Import:
     case OMPThreadPrivate:
     case OMPCapturedExpr:
     case Empty:
+    case RequiresExprBody:
       // Never looked up by name.
       return 0;
   }
 
   llvm_unreachable("Invalid DeclKind!");
 }
 
 void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
DeclContext *DeclContext::getPrimaryContext() {
   switch (DeclKind) {
   case Decl::TranslationUnit:
   case Decl::ExternCContext:
   case Decl::LinkageSpec:
   case Decl::Export:
   case Decl::Block:
   case Decl::Captured:
   case Decl::OMPDeclareReduction:
+  case Decl::RequiresExprBody:
     // There is only one DeclContext for these entities.
     return this;
 
   case Decl::Namespace:
     // The original namespace is our primary context.
     return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
 
   case Decl::ObjCMethod:

lib/AST/DeclCXX.cpp

 
 CXXDeductionGuideDecl *CXXDeductionGuideDecl::CreateDeserialized(ASTContext &C,
                                                                  unsigned ID) {
   return new (C, ID) CXXDeductionGuideDecl(C, nullptr, SourceLocation(), false,
                                            DeclarationNameInfo(), QualType(),
                                            nullptr, SourceLocation());
 }
 
+RequiresExprBodyDecl *RequiresExprBodyDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation StartLoc) {
+  return new (C, DC) RequiresExprBodyDecl(C, DC, StartLoc);
+}
+
+RequiresExprBodyDecl *RequiresExprBodyDecl::CreateDeserialized(ASTContext &C,
+                                                               unsigned ID) {
+  return new (C, ID) RequiresExprBodyDecl(C, nullptr, SourceLocation());
+}
+
 void CXXMethodDecl::anchor() {}
 
 bool CXXMethodDecl::isStatic() const {
   const CXXMethodDecl *MD = getCanonicalDecl();
 
   if (MD->getStorageClass() == SC_Static)
     return true;
 

lib/AST/Expr.cpp

bool Expr::HasSideEffects(const ASTContext &Ctx,
   case SizeOfPackExprClass:
   case ObjCStringLiteralClass:
   case ObjCEncodeExprClass:
   case ObjCBoolLiteralExprClass:
   case ObjCAvailabilityCheckExprClass:
   case CXXUuidofExprClass:
   case OpaqueValueExprClass:
   case ConceptSpecializationExprClass:
+  case RequiresExprClass:
     // These never have a side-effect.
     return false;
 
   case CallExprClass:
   case CXXOperatorCallExprClass:
   case CXXMemberCallExprClass:
   case CUDAKernelCallExprClass:
   case UserDefinedLiteralClass: {

lib/AST/ExprCXX.cpp

 
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclAccessPair.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "clang/Sema/Sema.h"
+#include "clang/Sema/Overload.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <memory>
+#include <clang/Sema/Lookup.h>
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 //  Child Iterators for iterating over subexpressions/substatements
 //===----------------------------------------------------------------------===//
 
 bool CXXOperatorCallExpr::isInfixBinaryOp() const {
bool ConceptSpecializationExpr::setTemplateArguments(ASTContext &C, Sema *S,
 
   if (S->CheckConstraintSatisfaction(NamedConcept,
                                      NamedConcept->getConstraintExpr(),
                                      Converted, ConceptNameLoc, Satisfaction)) {
     S->Diag(getLocStart(), diag::note_in_concept_specialization) << this;
     return true;
   }
   return false;
+}
+
+RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
+                           RequiresExprBodyDecl *Body,
+                           ArrayRef<ParmVarDecl *> LocalParameters,
+                           ArrayRef<Requirement *> Requirements,
+                           SourceLocation RBraceLoc)
+  : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary,
+         /*TD=*/false, /*VD=*/false, /*ID=*/false,
+         /*ContainsUnexpandedParameterPack=*/false), IsSatisfied(false),
+    RequiresKWLoc(RequiresKWLoc), Body(Body), RBraceLoc(RBraceLoc) {
+  setLocalParameters(LocalParameters);
+  setRequirements(Requirements);
+}
+
+void RequiresExpr::setLocalParameters(ArrayRef<ParmVarDecl *> LocalParameters) {
+  assert(this->LocalParameters.empty() && !isInstantiationDependent()
+         && !containsUnexpandedParameterPack() &&
+         "setLocalParameters must be called before setRequirements and may not "
+         "be called twice");
+  bool Dependent = false;
+  bool ContainsUnexpandedParameterPack = false;
+  for (ParmVarDecl *P : LocalParameters) {
+    Dependent |= P->getType()->isInstantiationDependentType();
+    ContainsUnexpandedParameterPack |=
+        P->getType()->containsUnexpandedParameterPack();
+  }
+  this->LocalParameters.assign(LocalParameters.begin(), LocalParameters.end());
+  setValueDependent(Dependent);
+  setInstantiationDependent(Dependent);
+  setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack);
+}
+
+void RequiresExpr::setRequirements(ArrayRef<Requirement *> Requirements) {
+  assert(this->Requirements.empty() && "setRequirements may only be called "
+                                       "once per object.");
+  bool Dependent = false;
+  bool ContainsUnexpandedParameterPack = false;
+  IsSatisfied = true;
+  for (Requirement *R : Requirements) {
+    Dependent |= R->isDependent();
+    ContainsUnexpandedParameterPack |= R->containsUnexpandedParameterPack();
+    if (!Dependent)
+      IsSatisfied &= R->isSatisfied();
+  }
+  this->Requirements.assign(Requirements.begin(), Requirements.end());
+  IsSatisfied |= Dependent;
+  // SetLocalParameters may have been called and may have updated the
+  // flags
+  if (!isInstantiationDependent() && Dependent) {
+    setValueDependent(Dependent);
+    setInstantiationDependent(Dependent);
+  }
+  if (!containsUnexpandedParameterPack() && ContainsUnexpandedParameterPack) {
+    setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack);
+  }
 }
 No newline at end of file

lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ObjCIndirectCopyRestoreExprClass:
   case Expr::AtomicExprClass:
   case Expr::CXXFoldExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
   case Expr::ConceptSpecializationExprClass:
+  case Expr::RequiresExprClass:
     return Cl::CL_PRValue;
 
     // Next come the complicated cases.
   case Expr::SubstNonTypeTemplateParmExprClass:
     return ClassifyInternal(Ctx,
                  cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
 
     // C, C++98 [expr.sub]p1: The result is an lvalue of type "T".

lib/AST/ExprConstant.cpp

public:
 
   bool VisitUnaryReal(const UnaryOperator *E);
   bool VisitUnaryImag(const UnaryOperator *E);
 
   bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
   bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
 
   bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
+  bool VisitRequiresExpr(const RequiresExpr *E);
   // FIXME: Missing: array subscript of vector, member of vector
 };
 } // end anonymous namespace
 
 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
 /// produce either the integer value or a pointer.
 ///
 /// GCC has a heinous extension which folds casts between pointer types and

 
 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
   return Success(E->getValue(), E);
 }
 
 bool IntExprEvaluator::VisitConceptSpecializationExpr(
        const ConceptSpecializationExpr *E) {
   if (E->isValueDependent()) {
     return Error(E);
   }
   return Success(E->isSatisfied(), E);
 }
 
+bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) {
+  if (E->isValueDependent()) {
+    return Error(E);
+  }
+  return Success(E->isSatisfied(), E);
+}
+
 
 //===----------------------------------------------------------------------===//
 // Float Evaluation
 //===----------------------------------------------------------------------===//
 
 namespace {
 class FloatExprEvaluator
   : public ExprEvaluatorBase<FloatExprEvaluator> {
case Expr::GenericSelectionExprClass:
     return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
   case Expr::IntegerLiteralClass:
   case Expr::CharacterLiteralClass:
   case Expr::ObjCBoolLiteralExprClass:
   case Expr::CXXBoolLiteralExprClass:
   case Expr::CXXScalarValueInitExprClass:
   case Expr::TypeTraitExprClass:
   case Expr::ConceptSpecializationExprClass:
+  case Expr::RequiresExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::CXXNoexceptExprClass:
     return NoDiag();
   case Expr::CallExprClass:
   case Expr::CXXOperatorCallExprClass: {
     // C99 6.6/3 allows function calls within unevaluated subexpressions of
     // constant expressions, but they can never be ICEs because an ICE cannot

lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ObjCAvailabilityCheckExprClass:
   case Expr::OffsetOfExprClass:
   case Expr::PredefinedExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::TypeTraitExprClass:
   case Expr::ConceptSpecializationExprClass:
+  case Expr::RequiresExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   {

lib/AST/StmtPrinter.cpp

 }
 
 void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
   OS << E->getNamedConcept()->getName();
   printTemplateArgumentList(OS, E->getTemplateArgumentListInfo()->arguments(),
                             Policy);
 }
 
+void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) {
+  OS << "requires ";
+  auto LocalParameters = E->getLocalParameters();
+  if (!LocalParameters.empty()) {
+    OS << "(";
+    for (ParmVarDecl *LocalParam : LocalParameters) {
+      PrintRawDecl(LocalParam);
+      if (LocalParam != LocalParameters.back())
+        OS << ", ";
+    }
+
+    OS << ") ";
+  }
+  OS << "{ ";
+  auto Requirements = E->getRequirements();
+  for (Requirement *Req : Requirements) {
+    if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
+      OS << "typename ";
+      if (TypeReq->isSubstitutionFailure())
+        OS << "<<error-type>>";
+      else
+        TypeReq->getType()->getType().print(OS, Policy);
+    } else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req)) {
+      if (ExprReq->isCompound())
+        OS << "{ ";
+      if (ExprReq->isExprSubstitutionFailure())
+        OS << "<<error-expression>>";
+      else
+        PrintExpr(ExprReq->getExpr());
+      if (ExprReq->isCompound()) {
+        OS << " }";
+        if (ExprReq->getNoexceptLoc().isValid())
+          OS << " noexcept";
+        const auto &RetReq = ExprReq->getReturnTypeRequirement();
+        if (!RetReq.isEmpty()) {
+          OS << " -> ";
+          if (RetReq.isSubstitutionFailure())
+            OS << "<<error-type>>";
+          else if (RetReq.isTrailingReturnType())
+            RetReq.getTrailingReturnTypeExpectedType()->getType().print(OS,
+                                                                        Policy);
+          else if (RetReq.isConstrainedParameter()) {
+            // This is kind of hacky - print out the type name, and replace its
+            // name with the constraint expr, omitting the first argument
+            // "const volatile <expr-type>&"
+            //  -> "const volatile ConstructibleWith<int>&"
+            // The invented template parameter should therefore have a
+            // non-user-typable name.
+            std::string ConstraintExprBuf;
+            llvm::raw_string_ostream ConstraintExprOS(ConstraintExprBuf);
+            auto *CSE = cast<ConceptSpecializationExpr>(
+                            RetReq.getConstrainedParamTemplateParameterList()
+                                ->getRequiresClause());
+            ConstraintExprOS << CSE->getNamedConcept()->getName();
+            if (CSE->getTemplateArgumentListInfo()->NumTemplateArgs > 1) {
+              ConstraintExprOS << "<";
+              for (unsigned I = 1,
+                   C = CSE->getTemplateArgumentListInfo()->NumTemplateArgs;
+                   I < C; ++I) {
+                CSE->getTemplateArgumentListInfo()->arguments()[I].getArgument()
+                    .print(Policy, ConstraintExprOS);
+                if (I != 1)
+                  ConstraintExprOS << ", ";
+              }
+              ConstraintExprOS << ">";
+            }
+            ConstraintExprOS.flush();
+
+            std::string ExpectedTypeBuf;
+            llvm::raw_string_ostream ExpectedTypeOS(ExpectedTypeBuf);
+            RetReq.getConstrainedParamExpectedType()->getType()
+                .print(ExpectedTypeOS, Policy);
+            ExpectedTypeOS.flush();
+            StringRef InventedParamName =
+                RetReq.getConstrainedParamTemplateParameterList()->getParam(0)
+                    ->getName();
+            ExpectedTypeBuf.replace(ExpectedTypeBuf.find(InventedParamName),
+                                    InventedParamName.size(),
+                                    ConstraintExprBuf);
+            OS << ExpectedTypeBuf;
+          }
+        }
+      }
+    } else {
+      auto *NestedReq = cast<NestedRequirement>(Req);
+      OS << "requires ";
+      if (NestedReq->isSubstitutionFailure())
+        OS << "<<error-expression>>";
+      else
+        PrintExpr(NestedReq->getConstraintExpr());
+    }
+    OS << "; ";
+  }
+  OS << "}";
+}
+
 // C++ Coroutines TS
 
 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
   Visit(S->getBody());
 }
 
 void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
   OS << "co_return";

lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitConceptSpecializationExpr(
                                            const ConceptSpecializationExpr *S) {
   VisitExpr(S);
   VisitDecl(S->getNamedConcept());
   VisitTemplateArguments(S->getTemplateArgumentListInfo()->getTemplateArgs(),
                          S->getTemplateArgumentListInfo()->NumTemplateArgs);
 }
 
+void StmtProfiler::VisitRequiresExpr(const RequiresExpr *S) {
+  VisitExpr(S);
+  ID.AddInteger(S->getLocalParameters().size());
+  for (ParmVarDecl *LocalParam : S->getLocalParameters())
+    VisitDecl(LocalParam);
+  ID.AddInteger(S->getRequirements().size());
+  for (Requirement *Req : S->getRequirements()) {
+    if (auto *TypeReq = dyn_cast<TypeRequirement>(Req)) {
+      ID.AddInteger(Requirement::RK_Type);
+      ID.AddBoolean(TypeReq->isSubstitutionFailure());
+      if (!TypeReq->isSubstitutionFailure())
+        VisitType(TypeReq->getType()->getType());
+    } else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req)) {
+      ID.AddInteger(Requirement::RK_Compound);
+      ID.AddBoolean(ExprReq->isExprSubstitutionFailure());
+      if (!ExprReq->isExprSubstitutionFailure())
+        Visit(ExprReq->getExpr());
+      // C++2a [expr.prim.req.compound]p1 Example:
+      //    [...] The compound-requirement in C1 requires that x++ is a valid
+      //    expression. It is equivalent to the simple-requirement x++; [...]
+      // We therefore do not profile isSimple() here.
+      ID.AddBoolean(ExprReq->getNoexceptLoc().isValid());
+      const ExprRequirement::ReturnTypeRequirement &RetReq =
+          ExprReq->getReturnTypeRequirement();
+      if (RetReq.isEmpty()) {
+        ID.AddInteger(0);
+      } else if (RetReq.isTrailingReturnType()) {
+        ID.AddInteger(1);
+        VisitType(RetReq.getTrailingReturnTypeExpectedType()->getType());
+      } else if (RetReq.isConstrainedParameter()) {
+        ID.AddInteger(2);
+        Visit(RetReq.getConstrainedParamTemplateParameterList()
+                  ->getRequiresClause());
+        VisitType(RetReq.getConstrainedParamExpectedType()->getType());
+      } else {
+        assert(RetReq.isSubstitutionFailure());
+        ID.AddInteger(3);
+      }
+    } else {
+      ID.AddInteger(Requirement::RK_Nested);
+      auto *NestedReq = cast<NestedRequirement>(Req);
+      ID.AddBoolean(NestedReq->isSubstitutionFailure());
+      if (!NestedReq->isSubstitutionFailure())  
+        Visit(NestedReq->getConstraintExpr());
+    }
+  }
+}
+
 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
                                           UnaryOperatorKind &UnaryOp,
                                           BinaryOperatorKind &BinaryOp) {
   switch (S->getOperator()) {
   case OO_None:
   case OO_New:
   case OO_Delete:
   case OO_Array_New:

lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::CXXRecord: // struct/union/class X; [C++]
   case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
   case Decl::Label:        // __label__ x;
   case Decl::Import:
   case Decl::OMPThreadPrivate:
   case Decl::OMPCapturedExpr:
   case Decl::Empty:
   case Decl::Concept:
+  case Decl::RequiresExprBody:
     // None of these decls require codegen support.
     return;
 
   case Decl::NamespaceAlias:
     if (CGDebugInfo *DI = getDebugInfo())
         DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
     return;
   case Decl::Using:          // using X; [C++]

lib/CodeGen/CGExprScalar.cpp

public:
   Value *VisitTypeTraitExpr(const TypeTraitExpr *E) {
     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
   }
 
   Value *VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
     return Builder.getInt1(E->isSatisfied());
   }
 
+  Value *VisitRequiresExpr(const RequiresExpr *E) {
+    return Builder.getInt1(E->isSatisfied());
+  }
+
   Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
     return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
   }
 
   Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
     return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
   }
 

lib/Parse/ParseDecl.cpp

if (isFunctionDeclaratorIdentifierList()) {
     EndLoc = RParenLoc;
 
     // If there are attributes following the identifier list, parse them and 
     // prohibit them.
     MaybeParseCXX11Attributes(FnAttrs);
     ProhibitAttributes(FnAttrs);
   } else {
     if (Tok.isNot(tok::r_paren))
-      ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, 
+      ParseParameterDeclarationClause(D.getContext(), FirstArgAttrs, ParamInfo,
                                       EllipsisLoc);
     else if (RequiresArg)
       Diag(Tok, diag::err_argument_required_after_attribute);
 
     HasProto = ParamInfo.size() || getLangOpts().CPlusPlus
                                 || getLangOpts().OpenCL;
 
     // If we have the closing ')', eat it.
do {
     // The list continues if we see a comma.
   } while (TryConsumeToken(tok::comma));
 }
 
 /// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list
 /// after the opening parenthesis. This function will not parse a K&R-style
 /// identifier list.
 ///
-/// D is the declarator being parsed.  If FirstArgAttrs is non-null, then the
-/// caller parsed those arguments immediately after the open paren - they should
-/// be considered to be part of the first parameter.
+/// DeclContext is the context of the declarator being parsed.  If FirstArgAttrs
+/// is non-null, then the caller parsed those attributes immediately after the
+/// open paren - they should be considered to be part of the first parameter.
 ///
 /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will
 /// be the location of the ellipsis, if any was parsed.
 ///
 ///       parameter-type-list: [C99 6.7.5]
 ///         parameter-list
 ///         parameter-list ',' '...'
 /// [C++]   parameter-list '...'

 /// [GNU]   declaration-specifiers declarator attributes
 ///         declaration-specifiers abstract-declarator[opt]
 /// [C++]   declaration-specifiers abstract-declarator[opt]
 ///           '=' assignment-expression
 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
 /// [C++11] attribute-specifier-seq parameter-declaration
 ///
 void Parser::ParseParameterDeclarationClause(
-       Declarator &D,
+       Declarator::TheContext DeclaratorContext,
        ParsedAttributes &FirstArgAttrs,
        SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
        SourceLocation &EllipsisLoc) {
   do {
     // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
     // before deciding this was a parameter-declaration-clause.
     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
       break;
do {
 
     ParseDeclarationSpecifiers(DS);
 
 
     // Parse the declarator.  This is "PrototypeContext" or 
     // "LambdaExprParameterContext", because we must accept either 
     // 'declarator' or 'abstract-declarator' here.
     Declarator ParmDeclarator(DS, 
-              D.getContext() == Declarator::LambdaExprContext ?
+              DeclaratorContext == Declarator::RequiresExprContext ?
+                  Declarator::RequiresExprContext :
+                  DeclaratorContext == Declarator::LambdaExprContext ?
                                   Declarator::LambdaExprParameterContext : 
                                                 Declarator::PrototypeContext);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.
     MaybeParseGNUAttributes(ParmDeclarator);
 
     // Remember this parsed parameter in ParamInfo.
if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
       // Parse the default argument, if any. We parse the default
       // arguments in all dialects; the semantic analysis in
       // ActOnParamDefaultArgument will reject the default argument in
       // C.
       if (Tok.is(tok::equal)) {
         SourceLocation EqualLoc = Tok.getLocation();
 
         // Parse the default argument
-        if (D.getContext() == Declarator::MemberContext) {
+        if (DeclaratorContext == Declarator::MemberContext) {
           // If we're inside a class definition, cache the tokens
           // corresponding to the default argument. We'll actually parse
           // them when we see the end of the class definition.
           DefArgToks.reset(new CachedTokens);
 
           SourceLocation ArgStartLoc = NextToken().getLocation();
           if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) {
             DefArgToks.reset();

lib/Parse/ParseExpr.cpp

 /// [C++]   id-expression
 ///         constant
 ///         string-literal
 /// [C++]   boolean-literal  [C++ 2.13.5]
 /// [C++11] 'nullptr'        [C++11 2.14.7]
 /// [C++11] user-defined-literal
 ///         '(' expression ')'
 /// [C11]   generic-selection
+/// [C++2a] requires-expression
 ///         '__func__'        [C99 6.4.2.2]
 /// [GNU]   '__FUNCTION__'
 /// [MS]    '__FUNCDNAME__'
 /// [MS]    'L__FUNCTION__'
 /// [GNU]   '__PRETTY_FUNCTION__'
 /// [GNU]   '(' compound-statement ')'
 /// [GNU]   '__builtin_va_arg' '(' assignment-expression ',' type-name ')'
 /// [GNU]   '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')'
#include "clang/Basic/OpenCLImageTypes.def"
   }
 
   case tok::kw_new: // [C++] new-expression
     return ParseCXXNewExpression(false, Tok.getLocation());
 
   case tok::kw_delete: // [C++] delete-expression
     return ParseCXXDeleteExpression(false, Tok.getLocation());
 
+  case tok::kw_requires: // [C++2a] requires-expression
+    return ParseRequiresExpression();
+
   case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
     Diag(Tok, diag::warn_cxx98_compat_noexcept_expr);
     SourceLocation KeyLoc = ConsumeToken();
     BalancedDelimiterTracker T(*this, tok::l_paren);
 
     if (T.expectAndConsume(diag::err_expected_lparen_after, "noexcept"))
       return ExprError();
     // C++11 [expr.unary.noexcept]p1:

lib/Parse/ParseExprCXX.cpp

 //===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Expression parsing implementation for C++.
 //
 //===----------------------------------------------------------------------===//
 #include "clang/Parse/Parser.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "llvm/Support/ErrorHandling.h"
if (Tok.is(tok::l_paren)) {
     SourceLocation LParenLoc = T.getOpenLocation();
 
     // Parse parameter-declaration-clause.
     SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
     SourceLocation EllipsisLoc;
     
     if (Tok.isNot(tok::r_paren)) {
       Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
-      ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
+      ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo,
+                                      EllipsisLoc);
       // For a generic lambda, each 'auto' within the parameter declaration 
       // clause creates a template type parameter, so increment the depth.
       if (Actions.getCurGenericLambda()) 
         ++CurTemplateDepthTracker;
     }
     T.consumeClose();
     SourceLocation RParenLoc = T.getCloseLocation();
     SourceLocation DeclEndLoc = RParenLoc;
Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
 
   ExprResult Operand(ParseCastExpression(false));
   if (Operand.isInvalid())
     return Operand;
 
   return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
 }
 
+/// ParseRequiresExpression - Parse a C++2a requires-expression.
+/// C++2a [expr.prim.req]p1
+///     A requires-expression provides a concise way to express requirements on
+///     template arguments. A requirement is one that can be checked by name
+///     lookup (6.4) or by checking properties of types and expressions.
+///
+///     requires-expression:
+///         'requires' requirement-parameter-list[opt] requirement-body
+///
+///     requirement-parameter-list:
+///         '(' parameter-declaration-clause[opt] ')'
+///
+///     requirement-body:
+///         '{' requirement-seq '}'
+///
+///     requirement-seq:
+///         requirement
+///         requirement-seq requirement
+///
+///     requirement:
+///         simple-requirement
+///         type-requirement
+///         compound-requirement
+///         nested-requirement
+ExprResult Parser::ParseRequiresExpression() {
+  assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword");
+  SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires'
+
+  // C++2a [expr.prim.req]p2
+  // Expressions appearing within a requirement-body are unevaluated operands.
+  EnterExpressionEvaluationContext Ctx(
+      Actions, Sema::ExpressionEvaluationContext::Unevaluated);
+
+  llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
+  ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
+                                        Scope::DeclScope);
+  if (Tok.is(tok::l_paren)) {
+    // requirement parameter list is present.
+    BalancedDelimiterTracker Parens(*this, tok::l_paren);
+    Parens.consumeOpen();
+    if (!Tok.is(tok::r_paren)) {
+      ParsedAttributes FirstArgAttrs(getAttrFactory());
+      SourceLocation EllipsisLoc;
+      llvm::SmallVector<DeclaratorChunk::ParamInfo, 2> LocalParameters;
+      DiagnosticErrorTrap Trap(Diags);
+      ParseParameterDeclarationClause(Declarator::RequiresExprContext,
+                                      FirstArgAttrs, LocalParameters,
+                                      EllipsisLoc);
+      if (EllipsisLoc.isValid())
+        Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis);
+      for (auto &ParamInfo : LocalParameters)
+        LocalParameterDecls.push_back(cast<ParmVarDecl>(ParamInfo.Param));
+      if (Trap.hasErrorOccurred())
+        SkipUntil(tok::r_paren, StopBeforeMatch);
+    }
+    Parens.consumeClose();
+  }
+
+  BalancedDelimiterTracker Braces(*this, tok::l_brace);
+  if (Braces.expectAndConsume())
+    return ExprError();
+
+  // Start of requirement list
+  llvm::SmallVector<Requirement *, 2> Requirements;
+
+  if (Tok.is(tok::r_brace)) {
+    // Grammar does not allow an empty body.
+    // requirement-body:
+    //   { requirement-seq }
+    // requirement-seq:
+    //   requirement
+    //   requirement-seq requirement
+    Diag(Tok, diag::err_empty_requires_expr);
+    Braces.consumeClose();
+    return ExprError();
+  }
+
+  RequiresExprBodyDecl *Body = Actions.ActOnEnterRequiresExpr(
+      RequiresKWLoc, LocalParameterDecls, getCurScope());
+
+  while (!Tok.is(tok::r_brace)) {
+    auto FindSemi = [&] {
+      RevertingTentativeParsingAction RTPA(*this);
+      if (SkipUntil(tok::semi, StopBeforeMatch))
+        return Tok.getLocation();
+      ExpectAndConsumeSemi(diag::err_expected_semi_requirement);
+      return SourceLocation();
+    };
+    switch (Tok.getKind()) {
+    case tok::kw_typename: {
+      // Type requirement
+      // C++ [expr.prim.req.type]
+      //     type-requirement:
+      //         'typename' nested-name-specifier[opt] type-name ';'
+      SourceLocation TypenameKWLoc = ConsumeToken();
+      CXXScopeSpec SS;
+      if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
+                                         /*EnteringContext=*/false,
+                                         /*MayBePseudoDestructor=*/nullptr,
+                                         /*IsTypename=*/true) ||
+          SS.isInvalid()) {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      SourceLocation TemplateKWLoc;
+      UnqualifiedId TypeName;
+      SourceLocation IdLoc = Tok.getLocation();
+      if (ParseUnqualifiedId(SS, /*EnteringContext=*/false,
+                             /*AllowDestructorName*/false,
+                             /*AllowConstructorName=*/false,
+                             /*AllowDeductionGuide=*/false, ParsedType(),
+                             TemplateKWLoc, TypeName)) {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (TypeName.getKind() != UnqualifiedId::IK_Identifier &&
+          TypeName.getKind() != UnqualifiedId::IK_TemplateId) {
+        Diag(IdLoc, diag::err_requires_expr_type_req_illegal_identifier);
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (TypeName.getKind() == UnqualifiedId::IK_Identifier &&
+          Tok.is(tok::less)) {
+        SourceLocation ArgListLoc = ConsumeToken();
+        TemplateArgList List;
+        bool IsTAL;
+        {
+          bool WasSuppressed = Diags.getSuppressAllDiagnostics();
+          Diags.setSuppressAllDiagnostics();
+          RevertingTentativeParsingAction TPA(*this);
+          GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
+          IsTAL = !ParseTemplateArgumentList(List) &&
+                  TryConsumeToken(tok::greater);
+          Diags.setSuppressAllDiagnostics(WasSuppressed);
+        }
+        if (IsTAL) {
+          // Something like typename X<int> where X is not a template - the
+          // template arguments were not parsed as part of the unqualified id,
+          // so they are left here.
+          Diag(ArgListLoc,
+               diag::err_requires_expr_type_req_template_args_on_non_template)
+               << TypeName.Identifier->getName();
+          Braces.skipToEnd();
+          Actions.ActOnExitRequiresExpr();
+          return ExprError();
+        }
+        // This is just an extraneaous '<', handle it below.
+      }
+      if (auto *Req = Actions.ActOnTypeRequirement(TypenameKWLoc, std::move(SS),
+                                                   TypeName))
+        Requirements.push_back(Req);
+      else {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      break;
+    }
+    case tok::l_brace: {
+      // Compound requirement
+      // C++ [expr.prim.req.compound]
+      //     compound-requirement:
+      //         '{' expression '}' 'noexcept'[opt]
+      //             return-type-requirement[opt] ';'
+      //     return-type-requirement:
+      //         trailing-return-type
+      //         '->' cv-qualifier-seq[opt] constrained-parameter
+      //             cv-qualifier-seq[opt] abstract-declarator[opt]
+      BalancedDelimiterTracker ExprBraces(*this, tok::l_brace);
+      ExprBraces.consumeOpen();
+      ExprResult Expression = ParseExpression();
+      if (Expression.isInvalid() && !Expression.isUsable()) {
+        ExprBraces.skipToEnd();
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (ExprBraces.consumeClose())
+        ExprBraces.skipToEnd();
+
+      Requirement *Req = nullptr;
+      SourceLocation NoexceptLoc;
+      TryConsumeToken(tok::kw_noexcept, NoexceptLoc);
+      if (Tok.is(tok::semi)) {
+        Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc);
+        if (!Req) {
+          Braces.skipToEnd();
+          Actions.ActOnExitRequiresExpr();
+          return ExprError();
+        }
+        Requirements.push_back(Req);
+        break;
+      }
+      if (!Tok.is(tok::arrow)) {
+        // User probably forgot the arrow, remind him and try to continue
+        Diag(Tok, diag::err_requires_expr_missing_arrow)
+            << FixItHint::CreateInsertion(Tok.getLocation(), "->");
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      // Try to parse a 'constrained-parameter' requirement first.
+      auto TryConstrainedParameter = [&] {
+        TentativeParsingAction TPA(*this);
+        DeclSpec DS(AttrFactory);
+        ConsumeToken(); // consume '->'
+        auto ParseCV = [&] {
+          unsigned DiagID = 0;
+          const char *PrevSpec = nullptr;
+          while (true)
+            if (TryConsumeToken(tok::kw_const)) {
+              if (DS.SetTypeQual(DeclSpec::TQ_const, Tok.getLocation(),
+                                 PrevSpec, DiagID, getLangOpts()))
+                Diag(PrevTokLocation, DiagID) << PrevSpec
+                    << FixItHint::CreateRemoval(SourceRange(PrevTokLocation));
+            } else if (TryConsumeToken(tok::kw_volatile)) {
+              if (DS.SetTypeQual(DeclSpec::TQ_volatile, Tok.getLocation(),
+                                 PrevSpec, DiagID, getLangOpts()))
+                Diag(PrevTokLocation, DiagID) << PrevSpec
+                    << FixItHint::CreateRemoval(SourceRange(PrevTokLocation));
+            } else
+              break;
+        };
+        ParseCV();
+        ConceptDecl *CD;
+        SourceLocation ConceptNameLoc;
+        TemplateArgumentListInfo TALI;
+        if (!TryParseConstrainedParameter(CD, ConceptNameLoc, TALI)) {
+          TPA.Revert();
+          return false;
+        }
+        TPA.Commit();
+        if (!CD)
+          // An error occured while parsing the constrained parameter.
+          return true;
+        NamedDecl *ConceptPrototypeParm = CD->getTemplateParameters()
+                                            ->getParam(0);
+        if (!isa<TemplateTypeParmDecl>(ConceptPrototypeParm)) {
+          Diag(Tok,
+               diag::err_requires_expr_compound_requirement_non_type_concept)
+              << CD
+              << (isa<TemplateTemplateParmDecl>(ConceptPrototypeParm) ? 0
+                                                                      : 1);
+          return true;
+        }
+        ParseCV();
+
+        // Parse the abstract-declarator, if present.
+        Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
+        ParseDeclarator(DeclaratorInfo);
+
+        Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc,
+                                               ConceptNameLoc, CD, TALI,
+                                               DeclaratorInfo,
+                                               TemplateParameterDepth);
+        return true;
+      };
+
+      if (!TryConstrainedParameter()) {
+        SourceRange Range(Tok.getLocation(), FindSemi());
+        TypeResult ExpectedType = ParseTrailingReturnType(Range);
+        if (!ExpectedType.isUsable() || ExpectedType.isInvalid()) {
+          Braces.skipToEnd();
+          Actions.ActOnExitRequiresExpr();
+          return ExprError();
+        }
+        auto *LIT = cast<LocInfoType>(ExpectedType.get().get().getTypePtr());
+        Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc,
+                                               LIT->getTypeSourceInfo());
+      }
+      if (!Req) {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      Requirements.push_back(Req);
+      break;
+    }
+    case tok::kw_requires: {
+      // Nested requirement
+      // C++ [expr.prim.req.nested]
+      //     nested-requirement:
+      //         'requires' constraint-expression ';'
+      ConsumeToken();
+      ExprResult ConstraintExpr = ParseConstraintExpression();
+      if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (auto *Req = Actions.ActOnNestedRequirement(ConstraintExpr.get()))
+        Requirements.push_back(Req);
+      else {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      break;
+    }
+    default: {
+      // Simple requirement
+      // C++ [expr.prim.req.simple]
+      //     simple-requirement:
+      //         expression ';'
+      SourceLocation StartLoc = Tok.getLocation();
+      ExprResult Expression = ParseExpression();
+      if (Expression.isInvalid() || !Expression.isUsable()) {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get()))
+        Requirements.push_back(Req);
+      else {
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (!Tok.is(tok::semi) && !Tok.is(tok::r_brace)) {
+        // User may have tried to put some compound requirement stuff here
+        if (Tok.is(tok::kw_noexcept))
+          Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept)
+              << FixItHint::CreateInsertion(StartLoc, "{")
+              << FixItHint::CreateInsertion(Tok.getLocation(), "}");
+        else
+          Diag(Tok, diag::err_requires_expr_simple_requirement_unexpected_tok)
+              << Tok.getKind() << FixItHint::CreateInsertion(StartLoc, "{")
+              << FixItHint::CreateInsertion(Tok.getLocation(), "}");
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      break;
+    }
+    }
+    if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement))
+      break;
+  }
+  Braces.consumeClose();
+  Actions.ActOnExitRequiresExpr();
+  return Actions.CreateRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls,
+                                    Requirements, Braces.getCloseLocation());
+}
+
 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
   switch (kind) {
   default: llvm_unreachable("Not a known type trait");
 #define TYPE_TRAIT_1(Spelling, Name, Key) \
 case tok::kw_ ## Spelling: return UTT_ ## Name;
 #define TYPE_TRAIT_2(Spelling, Name, Key) \
 case tok::kw_ ## Spelling: return BTT_ ## Name;
 #include "clang/Basic/TokenKinds.def"

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/AST/RecursiveASTVisitor.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/Template.h"
+#include "clang/Sema/Overload.h"
+#include "clang/Sema/Initialization.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ExprCXX.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerUnion.h"
 using namespace clang;
 using namespace sema;
 
 bool Sema::CheckConstraintExpression(Expr *ConstraintExpression) {
if (CSE->getTemplateArgumentListInfo()->NumTemplateArgs == 1) {
           << CSE->getNamedConcept();
     } else {
       S.Diag(SubstExpr->getSourceRange().getBegin(),
              diag::note_concept_specialization_constraint_evaluated_to_false)
           << (int)First << CSE;
     }
     S.DiagnoseUnsatisfiedConstraint(CSE->getSatisfaction());
     return;
+  } else if (auto *RE = dyn_cast<RequiresExpr>(SubstExpr)) {
+    bool FirstReq = First;
+    for (Requirement *Req : RE->getRequirements())
+      if (!Req->isSatisfied()) {
+        Req->Diagnose(S, FirstReq);
+        FirstReq = false;
+      }
+    return;
   }
 
   S.Diag(SubstExpr->getSourceRange().getBegin(),
          diag::note_atomic_constraint_evaluated_to_false)
       << (int)First << SubstExpr;
 }
 
 static void diagnoseUnsatisfiedConstraintExpr(
     Sema &S, const Expr *E, ConstraintSatisfaction::Detail Detail,
     bool First = true) {
   if (auto *Diag =
           Detail.dyn_cast<ConstraintSatisfaction::SubstitutionDiagnostic *>()) {
     S.Diag(Diag->first, diag::note_substituted_constraint_expr_is_ill_formed)
         << Diag->second;
     return;
   }
 
   diagnoseWellFormedUnsatisfiedConstraintExpr(S, Detail.get<Expr *>(), First);
 }
 
-void Sema::DiagnoseUnsatisfiedConstraint(
-    const ConstraintSatisfaction& Satisfaction) {
+void
+Sema::DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction,
+                                    bool First) {
   assert(!Satisfaction.IsSatisfied &&
          "Attempted to diagnose a satisfied constraint");
-  bool First = true;
   for (auto &Pair : Satisfaction.Details) {
     diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First);
     First = false;
   }
 }
 namespace {
 struct AtomicConstraint {
   AtomicConstraint(Expr *ConstraintExpr,
bool Sema::IsMoreConstrained(NamedDecl *D1, Expr *AC1, NamedDecl *D2,
   std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
   auto CacheEntry = SubsumptionCache.find(Key);
   if (CacheEntry != SubsumptionCache.end()) {
     return CacheEntry->second;
   }
   bool Subsumes = subsumes(*this, AC1, AC2);
   SubsumptionCache.try_emplace(Key, Subsumes);
   return Subsumes;
+}
+
+
+ExprRequirement::ExprRequirement(Sema &S, Expr *E, bool IsSimple,
+                                 SourceLocation NoexceptLoc,
+                                 ReturnTypeRequirement Req) :
+    Requirement(IsSimple ? RK_Simple : RK_Compound,
+                E->isInstantiationDependent() || Req.isDependent(),
+                E->containsUnexpandedParameterPack() ||
+                Req.containsUnexpandedParameterPack(), false), Value(E),
+    NoexceptLoc(NoexceptLoc), TypeReq(Req) {
+  assert((!IsSimple || (Req.isEmpty() && NoexceptLoc.isInvalid())) &&
+         "Simple requirement must not have a return type requirement or a "
+         "noexcept specification");
+  if (isDependent()) {
+    Status = SS_Dependent;
+    return;
+  }
+  if (NoexceptLoc.isValid() && S.canThrow(E) == CanThrowResult::CT_Can) {
+    Status = SS_NoexceptNotMet;
+    setSatisfied(false);
+    return;
+  }
+  Status = TypeReq.calculateSatisfaction(S, E);
+  setSatisfied(Status == SS_Satisfied);
+}
+
+ExprRequirement::ExprRequirement(Expr *E, bool IsSimple,
+                                 SourceLocation NoexceptLoc,
+                                 ReturnTypeRequirement Req,
+                                 SatisfactionStatus Status) :
+    Requirement(IsSimple ? RK_Simple : RK_Compound, Status == SS_Dependent,
+                Status == SS_Dependent &&
+                (E->containsUnexpandedParameterPack() ||
+                 Req.containsUnexpandedParameterPack()),
+                Status == SS_Satisfied), Value(E), NoexceptLoc(NoexceptLoc),
+    TypeReq(Req), Status(Status) {
+  assert((!IsSimple || (Req.isEmpty() && NoexceptLoc.isInvalid())) &&
+         "Simple requirement must not have a return type requirement or a "
+         "noexcept specification");
+}
+
+ExprRequirement::ExprRequirement(SubstitutionDiagnostic *ExprSubstDiag,
+                                 bool IsSimple, SourceLocation NoexceptLoc,
+                                 ReturnTypeRequirement Req) :
+    Requirement(IsSimple ? RK_Simple : RK_Compound, Req.isDependent(),
+                Req.containsUnexpandedParameterPack(), /*IsSatisfied=*/false),
+    Value(ExprSubstDiag), NoexceptLoc(NoexceptLoc), TypeReq(Req),
+    Status(SS_ExprSubstitutionFailure) {
+  assert((!IsSimple || (Req.isEmpty() && NoexceptLoc.isInvalid())) &&
+         "Simple requirement must not have a return type requirement or a "
+         "noexcept specification");
+}
+
+ExprRequirement::ReturnTypeRequirement::ReturnTypeRequirement(ASTContext &C,
+    TypeSourceInfo *ExpectedType) :
+    Dependent(ExpectedType->getType()->isInstantiationDependentType()),
+    ContainsUnexpandedParameterPack(
+        ExpectedType->getType()->containsUnexpandedParameterPack()),
+    Value(ExpectedType) {}
+
+class NonInventedTemplateParameterFinder :
+    public RecursiveASTVisitor<NonInventedTemplateParameterFinder> {
+public:
+  NonInventedTemplateParameterFinder(const TemplateTypeParmType *InventedType) :
+      InventedType(InventedType) {}
+
+  bool containsNonInventedTemplateParameter(QualType T) {
+    return !TraverseType(T);
+  }
+
+  bool containsNonInventedTemplateParameter(Expr *E) {
+    return !TraverseStmt(E);
+  }
+
+  bool TraverseTemplateTypeParmType(TemplateTypeParmType *T) {
+    return T == InventedType;
+  }
+
+private:
+  const TemplateTypeParmType *InventedType;
+};
+
+ExprRequirement::ReturnTypeRequirement::ReturnTypeRequirement(ASTContext &C,
+    TemplateParameterList *TPL, TypeSourceInfo *ExpectedType) :
+    Dependent(false),
+    ContainsUnexpandedParameterPack(
+        TPL->getRequiresClause()->containsUnexpandedParameterPack() ||
+        ExpectedType->getType()->containsUnexpandedParameterPack()),
+    Value(new (C) ConstrainedParam(ExpectedType, TPL, nullptr)) {
+  assert(TPL->size() == 1 &&
+         isa<ConceptSpecializationExpr>(TPL->getRequiresClause()) &&
+         "Provided template parameter list is ill-formed (must contain "
+         "exactly one type parameter and have a concept specialization "
+         "expression for a requires clause");
+  // TODO: Is this really necessary?
+  NonInventedTemplateParameterFinder Finder(
+      cast<TemplateTypeParmType>(
+          cast<TemplateTypeParmDecl>(TPL->getParam(0))->getTypeForDecl()));
+  Dependent = Finder.containsNonInventedTemplateParameter(ExpectedType
+                                                              ->getType()) ||
+      Finder.containsNonInventedTemplateParameter(TPL->getRequiresClause());
+}
+
+ExprRequirement::ReturnTypeRequirement::ReturnTypeRequirement(ASTContext &C,
+    TemplateParameterList *TPL, TypeSourceInfo *ExpectedType,
+    ConceptSpecializationExpr *CSE) :
+    Dependent(TPL->getRequiresClause()->isInstantiationDependent() ||
+              ExpectedType->getType()->isInstantiationDependentType()),
+    ContainsUnexpandedParameterPack(
+        TPL->getRequiresClause()->containsUnexpandedParameterPack() ||
+        ExpectedType->getType()->containsUnexpandedParameterPack()),
+    Value(new (C) ConstrainedParam(ExpectedType, TPL, CSE)) {}
+
+ExprRequirement::SatisfactionStatus
+ExprRequirement::ReturnTypeRequirement::calculateSatisfaction(Sema &S,
+    Expr *E) {
+  if (!Value)
+    return SS_Satisfied;
+  if (Value.is<SubstitutionDiagnostic *>())
+    return SS_TypeRequirementSubstitutionFailure;
+  if (auto *TypeReq = Value.dyn_cast<TypeSourceInfo *>()) {
+    if (E->getType() == TypeReq->getType())
+      return SS_Satisfied;
+    InitializedEntity InventedEntity =
+        InitializedEntity::InitializeResult(TypeReq->getTypeLoc().getLocStart(),
+                                            TypeReq->getType(), /*NRVO=*/false);
+    InitializationSequence Seq(S, InventedEntity,
+        InitializationKind::CreateCopy(E->getLocStart(),
+                                       TypeReq->getTypeLoc().getLocStart()), E);
+    if (Seq.isAmbiguous())
+      return SS_ImplicitConversionAmbiguous;
+    if (Seq.Failed())
+      return SS_NoImplicitConversionExists;
+    return SS_Satisfied;
+  }
+  auto *Constrained = Value.get<ConstrainedParam *>();
+  QualType MatchedType = S.matchTypeByDeduction(std::get<1>(*Constrained),
+      std::get<0>(*Constrained)->getType().getCanonicalType(), E);
+  if (MatchedType.isNull())
+    return SS_DeductionFailed;
+  llvm::SmallVector<TemplateArgument, 1> Args;
+  Args.push_back(TemplateArgument(MatchedType));
+  TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args);
+  MultiLevelTemplateArgumentList MLTAL(TAL);
+  ExprResult Constraint = S.SubstExpr(
+      std::get<1>(*Constrained)->getRequiresClause(), MLTAL);
+  assert(!Constraint.isInvalid() && Constraint.isUsable() &&
+         "Substitution cannot fail as it is simply putting a type template "
+         "argument into a concept specialization expression's parameter.");
+
+  auto *CSE = cast<ConceptSpecializationExpr>(Constraint.get());
+  std::get<2>(*Constrained) = CSE;
+  if (!CSE->isSatisfied())
+    return SS_ConstraintsNotSatisfied;
+  return SS_Satisfied;
+}
+
+void ExprRequirement::Diagnose(Sema &S, bool First) const {
+  assert(!isSatisfied()
+         && "Diagnose() can only be used on an unsatisfied requirement");
+  switch (getSatisfactionStatus()) {
+  case SS_Dependent:
+    llvm_unreachable("Diagnosing a dependent requirement");
+    break;
+  case SS_ExprSubstitutionFailure: {
+    auto *SubstDiag = getExprSubstitutionDiagnostic();
+    S.Diag(SubstDiag->DiagLoc,
+           diag::note_expr_requirement_expr_substitution_error) << (int)First
+        << SubstDiag->SubstitutedEntity
+        << SubstDiag->DiagMessage;
+    break;
+  }
+  case SS_NoexceptNotMet:
+    S.Diag(getNoexceptLoc(), diag::note_expr_requirement_noexcept_not_met)
+        << (int)First << getExpr();
+    break;
+  case SS_TypeRequirementSubstitutionFailure: {
+    auto *SubstDiag = TypeReq.getSubstitutionDiagnostic();
+    S.Diag(SubstDiag->DiagLoc,
+           diag::note_expr_requirement_type_requirement_substitution_error)
+        << (int)First << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    break;
+  }
+  case SS_ImplicitConversionAmbiguous:
+    S.Diag(TypeReq.getTrailingReturnTypeExpectedType()
+               ->getTypeLoc().getLocStart(),
+           diag::note_expr_requirement_ambiguous_conversion) << (int)First
+        << getExpr()->getType()
+        << TypeReq.getTrailingReturnTypeExpectedType()
+            ->getType();
+    break;
+  case SS_NoImplicitConversionExists:
+    S.Diag(TypeReq.getTrailingReturnTypeExpectedType()
+               ->getTypeLoc().getLocStart(),
+           diag::note_expr_requirement_no_implicit_conversion) << (int)First
+        << getExpr()->getType()
+        << TypeReq.getTrailingReturnTypeExpectedType()
+            ->getType();
+    break;
+  case SS_DeductionFailed: {
+    std::string ExpectedTypeBuf;
+    llvm::raw_string_ostream ExpectedTypeOS(ExpectedTypeBuf);
+    TypeReq.getConstrainedParamExpectedType()->getType()
+        .print(ExpectedTypeOS, S.getPrintingPolicy());
+    ExpectedTypeOS.flush();
+    StringRef InventedParamName =
+        TypeReq.getConstrainedParamTemplateParameterList()->getParam(0)
+            ->getName();
+    ExpectedTypeBuf.replace(ExpectedTypeBuf.find(InventedParamName),
+                            InventedParamName.size(), "<type>");
+    S.Diag(TypeReq.getConstrainedParamExpectedType()
+               ->getTypeLoc().getLocStart(),
+           diag::note_expr_requirement_deduction_failed) << (int)First
+        << getExpr()->getType() << ExpectedTypeBuf;
+    break;
+  }
+  case SS_ConstraintsNotSatisfied: {
+    ConceptSpecializationExpr *ConstraintExpr =
+        TypeReq.getConstrainedParamConstraintExpr();
+    if (ConstraintExpr->getTemplateArgumentListInfo()->NumTemplateArgs == 1 &&
+        TypeReq.getConstrainedParamExpectedType()->getType()
+        == QualType(
+            cast<TemplateTypeParmDecl>(
+                TypeReq.getConstrainedParamTemplateParameterList()->getParam(0))
+                ->getTypeForDecl(), 0))
+      // A simple case - expr type is the type being constrained and the concept
+      // was not provided arguments.
+      S.Diag(ConstraintExpr->getLocStart(),
+           diag::note_expr_requirement_constraints_not_satisfied_simple)
+          << (int)First << getExpr()->getType()
+          << ConstraintExpr->getNamedConcept();
+    else
+      S.Diag(ConstraintExpr->getLocStart(),
+             diag::note_expr_requirement_constraints_not_satisfied)
+          << (int)First << ConstraintExpr;
+    S.DiagnoseUnsatisfiedConstraint(ConstraintExpr->getSatisfaction());
+    break;
+  }
+  case SS_Satisfied:
+    llvm_unreachable("We checked this above");
+  }
+}
+
+TypeRequirement::TypeRequirement(TypeSourceInfo *T) :
+    Requirement(RK_Type, T->getType()->isDependentType(),
+                T->getType()->containsUnexpandedParameterPack(),
+                /*IsSatisfied=*/true // We reach this ctor with either dependent
+                                     // types (in which IsSatisfied doesn't
+                                     // matter) or with non-dependent type in
+                                     // which the existance of the type
+                                     // indicates satisfaction.
+                ), Value(T),
+    Status(T->getType()->isDependentType() ? SS_Dependent : SS_Satisfied) {}
+
+void TypeRequirement::Diagnose(Sema &S, bool First) const {
+  assert(!isSatisfied()
+         && "Diagnose() can only be used on an unsatisfied requirement");
+  switch (getSatisfactionStatus()) {
+  case SS_Dependent:
+    llvm_unreachable("Diagnosing a dependent requirement");
+    return;
+  case SS_SubstitutionFailure: {
+    auto *SubstDiag = getSubstitutionDiagnostic();
+    S.Diag(SubstDiag->DiagLoc,
+           diag::note_type_requirement_substitution_error) << (int)First
+        << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    return;
+  }
+  default:
+    llvm_unreachable("Unknown satisfaction status");
+    return;
+  }
+}
+
+NestedRequirement::NestedRequirement(Sema &S, Expr *Constraint) :
+    Requirement(RK_Nested, Constraint->isInstantiationDependent(),
+                Constraint->containsUnexpandedParameterPack(),
+                /*Satisfied=*/false), Value(Constraint) {
+  if (isDependent())
+    return;
+  S.CheckConstraintSatisfaction(Constraint, Satisfaction);
+  setSatisfied(Satisfaction.IsSatisfied);
+}
+
+void NestedRequirement::Diagnose(Sema &S, bool First) const {
+  if (isSubstitutionFailure()) {
+    auto *SubstDiag = getSubstitutionDiagnostic();
+    S.Diag(SubstDiag->DiagLoc,
+           diag::note_nested_requirement_substitution_error) << (int)First
+        << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    return;
+  }
+  S.DiagnoseUnsatisfiedConstraint(Satisfaction, First);
 }
 No newline at end of file

lib/Sema/SemaDecl.cpp

 static bool shouldConsiderLinkage(const VarDecl *VD) {
   const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
   if (DC->isFunctionOrMethod() || isa<OMPDeclareReductionDecl>(DC))
     return VD->hasExternalStorage();
   if (DC->isFileContext())
     return true;
   if (DC->isRecord())
     return false;
+  if (isa<RequiresExprBodyDecl>(DC))
+    return false;
   llvm_unreachable("Unexpected context");
 }
 
 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
   const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
   if (DC->isFileContext() || DC->isFunctionOrMethod() ||
       isa<OMPDeclareReductionDecl>(DC))
     return true;

lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Expr *E) {
   case Expr::ObjCEncodeExprClass:
   case Expr::ObjCStringLiteralClass:
   case Expr::ObjCBoolLiteralExprClass:
   case Expr::OpaqueValueExprClass:
   case Expr::PredefinedExprClass:
   case Expr::SizeOfPackExprClass:
   case Expr::StringLiteralClass:
   case Expr::ConceptSpecializationExprClass:
+  case Expr::RequiresExprClass:
     // These expressions can never throw.
     return CT_Cannot;
 
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
     llvm_unreachable("Invalid class for expression");
 
 #define STMT(CLASS, PARENT) case Expr::CLASS##Class:

lib/Sema/SemaExpr.cpp

 ExprResult
 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                        SourceLocation Loc,
                        const CXXScopeSpec *SS) {
   DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
   return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
 }
 
+static bool isEvaluatableContext(Sema &SemaRef);
+
 /// BuildDeclRefExpr - Build an expression that references a
 /// declaration that does not require a closure capture.
 ExprResult
 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                        const DeclarationNameInfo &NameInfo,
                        const CXXScopeSpec *SS, NamedDecl *FoundD,
                        const TemplateArgumentListInfo *TemplateArgs) {
   bool RefersToCapturedVariable =
       isa<VarDecl>(D) &&
       NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc());
 
+  if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->getDeclContext()) &&
+      isEvaluatableContext(*this)) {
+    // C++ [expr.prim.req.nested] p3
+    //   A local parameter shall only appear as an unevaluated operand
+    //   (Clause 8) within the constraint-expression.
+    //
+    // We take the liberty of disallowing these parameters in any evaluated
+    // context.
+    Diag(NameInfo.getLocStart(),
+         diag::err_requires_expr_parameter_referenced_in_evaluated_context)
+        << D;
+    Diag(D->getLocation(), diag::note_entity_declared_at) << D;
+    return ExprError();
+  }
+
   DeclRefExpr *E;
   if (isa<VarTemplateSpecializationDecl>(D)) {
     VarTemplateSpecializationDecl *VarSpec =
         cast<VarTemplateSpecializationDecl>(D);
 
     E = DeclRefExpr::Create(Context, SS ? SS->getWithLocInContext(Context)
                                         : NestedNameSpecifierLoc(),
                             VarSpec->getTemplateKeywordLoc(), D,

lib/Sema/SemaExprCXX.cpp

Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
   auto UPPC = IsIfExists ? UPPC_IfExists : UPPC_IfNotExists;
   if (DiagnoseUnexpandedParameterPack(SS, UPPC) ||
       DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC))
     return IER_Error;
 
   return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
 }
 
-
 ExprResult
 Sema::CreateConceptSpecializationExpr(SourceLocation ConceptNameLoc,
                                       ConceptDecl *CTD,
                                       const TemplateArgumentListInfo *TALI) {
   return new (Context) ConceptSpecializationExpr(Context, *this, ConceptNameLoc,
                                                  CTD, TALI);
+}
+
+Requirement *Sema::ActOnSimpleRequirement(Expr *E) {
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/true,
+             /*NoexceptLoc=*/SourceLocation());
+}
+
+Requirement *Sema::ActOnTypeRequirement(SourceLocation TypenameKWLoc,
+                                        CXXScopeSpec TypeScope,
+                                        UnqualifiedId &TypeName) {
+  llvm::Optional<ASTTemplateArgumentListInfo> TALI;
+  assert((TypeName.getKind() == UnqualifiedId::IK_TemplateId ||
+          TypeName.getKind() == UnqualifiedId::IK_Identifier) &&
+         "Only template-id or identifier allowed in type requirement.");
+
+  TemplateArgumentListInfo TemplateArgsBuffer;
+
+  // Decompose the UnqualifiedId into the following data.
+  DeclarationNameInfo NameInfo;
+  const TemplateArgumentListInfo *TemplateArgs;
+  DecomposeUnqualifiedId(TypeName, TemplateArgsBuffer, NameInfo, TemplateArgs);
+
+  QualType T;
+  if (TemplateArgs) {
+    llvm::Optional<TemplateName> TempName;
+    if (TypeScope.isSet()) {
+      UnqualifiedId TemplateId;
+      TemplateId.setIdentifier(NameInfo.getName().getAsIdentifierInfo(),
+                               NameInfo.getBeginLoc());
+      TemplateTy TemplateType;
+      auto TNK = ActOnDependentTemplateName(CurScope, TypeScope,
+                                            SourceLocation(),
+                                            TemplateId, ParsedType(),
+                                            /*EnteringContext=*/false,
+                                            TemplateType);
+      if (TNK != TNK_Type_template && TNK != TNK_Dependent_template_name) {
+        std::string Buf;
+        llvm::raw_string_ostream OS(Buf);
+        TemplateType.get().print(OS, getPrintingPolicy());
+        Diag(NameInfo.getBeginLoc(),
+             diag::err_type_requirement_non_type_template) << OS.str()
+            << (int)getTemplateNameKindForDiagnostics(TemplateType.get())
+            << NameInfo.getSourceRange();
+        return nullptr;
+      }
+      TempName.emplace(TemplateType.get());
+    } else {
+      LookupResult R(*this, NameInfo, LookupOrdinaryName);
+      bool MemberOfUnknownSpecialization = false;
+      LookupTemplateName(R, CurScope, TypeScope, /*ObjectType=*/QualType(),
+                         /*EnteringContext=*/false,
+                         MemberOfUnknownSpecialization);
+      assert(!MemberOfUnknownSpecialization
+             && "How did this happen without a type scope");
+
+      if (!R.isSingleResult())
+        return nullptr;
+      TemplateDecl *Result = R.getAsSingle<TemplateDecl>();
+      if (TemplateDecl *TypeTemplate = getAsTypeTemplateDecl(Result))
+        TempName.emplace(TypeTemplate);
+      else {
+        std::string Buf;
+        llvm::raw_string_ostream OS(Buf);
+        Result->printQualifiedName(OS);
+        Diag(NameInfo.getBeginLoc(),
+             diag::err_type_requirement_non_type_template) << OS.str()
+            << (int)getTemplateNameKindForDiagnostics(TemplateName(Result))
+            << NameInfo.getSourceRange();
+        return nullptr;
+      }
+    }
+    T = CheckTemplateIdType(TempName.getValue(), NameInfo.getBeginLoc(),
+                            TemplateArgsBuffer);
+  } else if (TypeScope.isSet() && isDependentScopeSpecifier(TypeScope))
+    T = ActOnTypenameType(CurScope, SourceLocation(), TypeScope,
+                          *NameInfo.getName().getAsIdentifierInfo(),
+                          NameInfo.getBeginLoc()).get().get();
+  else {
+    ParsedType Type = getTypeName(*NameInfo.getName().getAsIdentifierInfo(),
+                                  NameInfo.getBeginLoc(), CurScope,
+                                  TypeScope.isSet() ? &TypeScope : nullptr,
+                                  /*isClassName=*/false,
+                                  /*HasTrailingDot=*/false,
+                                  /*ObjectType=*/nullptr,
+                                  /*IsCtorOrDtorName=*/false,
+                                  /*WantNontrivialTypeSourceInfo=*/true,
+                                  /*IsClassTemplateDeductionContext=*/false);
+    if (!Type) {
+      std::string Buf;
+      llvm::raw_string_ostream OS(Buf);
+      if (TypeScope.isSet())
+        TypeScope.getScopeRep()->print(OS, getPrintingPolicy());
+      OS << NameInfo.getName().getAsString();
+      Diag(TypenameKWLoc, diag::err_type_requirement_no_such_type) << OS.str();
+      return nullptr;
+    }
+    T = Type.get();
+  }
+
+  if (T.isNull())
+    return nullptr;
+
+  auto *LIT = dyn_cast<LocInfoType>(T.getTypePtr());
+  return new (Context) TypeRequirement(
+      LIT ? LIT->getTypeSourceInfo() :
+      Context.getTrivialTypeSourceInfo(T, TypenameKWLoc));
+}
+
+Requirement *Sema::ActOnCompoundRequirement(Expr *E,
+                                            SourceLocation NoexceptLoc) {
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+                                       NoexceptLoc);
+}
+
+Requirement *Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
+                                            TypeSourceInfo *ExpectedType) {
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+             NoexceptLoc, ExprRequirement::ReturnTypeRequirement(Context,
+                                                                 ExpectedType));
+}
+
+Requirement *
+Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
+                               SourceLocation ConceptNameLoc,
+                               ConceptDecl *NamedConcept,
+                               TemplateArgumentListInfo TemplateArgs,
+                               Declarator &DeducedDeclarator, unsigned Depth) {
+  // C++2a [expr.prim.req.compound] p1.3.3
+  //   [..] the expression is deduced against an invented function template
+  //   F [...] F is a void function template with a single type template
+  //   parameter T declared with the constrained-parameter. Form a new
+  //   cv-qualifier-seq cv by taking the union of const and volatile specifiers
+  //   around the constrained-parameter. F has a single parameter whose
+  //   type-specifier is cv T followed by the abstract-declarator. [...]
+  //
+  // The cv part is done in the calling function - we get the concept with
+  // arguments and the abstract declarator with the correct CV qualification and
+  // have to synthesize T and the single parameter of F.
+  auto &II = Context.Idents.get("expr-type");
+  auto *TParam = TemplateTypeParmDecl::Create(Context, CurContext,
+                                              SourceLocation(),
+                                              SourceLocation(), Depth,
+                                              /*Index=*/0, &II,
+                                              /*Typename=*/true,
+                                              /*ParameterPack=*/false);
+  QualType TParamType(TParam->getTypeForDecl(), 0);
+
+  TemplateArgs.prependArgument(TemplateArgumentLoc(
+                                   TemplateArgument(TParamType),
+                                   TemplateArgumentLocInfo()));
+  ExprResult CSE = CreateConceptSpecializationExpr(ConceptNameLoc, NamedConcept,
+                                                   &TemplateArgs);
+  if (CSE.isInvalid())
+    return nullptr;
+
+  auto *TPL = TemplateParameterList::Create(Context, SourceLocation(),
+                                            SourceLocation(),
+                                            ArrayRef<NamedDecl *>(TParam),
+                                            SourceLocation(),
+                                            /*RequiresClause=*/CSE.get());
+
+  const char *PrevSpec;
+  unsigned DiagID;
+  ParsedType TParamParsedType = ParsedType::make(TParamType);
+  const_cast<DeclSpec &>(DeducedDeclarator.getDeclSpec())
+      .SetTypeSpecType(DeclSpec::TST_typename, ConceptNameLoc, PrevSpec,
+                       DiagID, TParamParsedType, Context.getPrintingPolicy());
+
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+      NoexceptLoc,
+      ExprRequirement::ReturnTypeRequirement(Context, TPL,
+          GetTypeForDeclarator(DeducedDeclarator, CurScope)));
+}
+
+Requirement *Sema::ActOnNestedRequirement(Expr *Constraint) {
+  return new (Context) NestedRequirement(*this, Constraint);
+}
+
+RequiresExprBodyDecl *
+Sema::ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc,
+                             ArrayRef<ParmVarDecl *> LocalParameters,
+                             Scope *LocalParametersScope) {
+  assert(LocalParametersScope);
+
+  RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(Context, CurContext,
+                                                            RequiresKWLoc);
+
+  // Maintain an efficient lookup of params we have seen so far.
+  llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
+
+  PushDeclContext(LocalParametersScope, Body);
+
+  for (ParmVarDecl *Param : LocalParameters) {
+    if (Param->hasDefaultArg())
+      // C++2a [expr.prim.req] p4
+      //     [...] A local parameter of a requires-expression shall not have a
+      //     default argument. [...]
+      Diag(Param->getDefaultArgRange().getBegin(),
+           diag::err_requires_expr_local_parameter_default_argument);
+    // Ignore default argument and move on
+
+    Param->setDeclContext(Body);
+    // If this has an identifier, add it to the scope stack.
+    if (Param->getIdentifier()) {
+      CheckShadow(LocalParametersScope, Param);
+
+      PushOnScopeChains(Param, LocalParametersScope);
+
+      // Verify that the argument identifier has not already been mentioned.
+      if (!ParamsSoFar.insert(Param->getIdentifier()).second)
+        Diag(Param->getLocStart(), diag::err_param_redefinition)
+            << Param->getIdentifier();
+    }
+  }
+  return Body;
+}
+
+void Sema::ActOnExitRequiresExpr() {
+  assert(CurContext && "DeclContext imbalance!");
+  CurContext = CurContext->getLexicalParent();
+  assert(CurContext && "Popped translation unit!");
+}
+
+ExprResult
+Sema::CreateRequiresExpr(SourceLocation RequiresKWLoc,
+                         RequiresExprBodyDecl *Body,
+                         ArrayRef<ParmVarDecl *> LocalParameters,
+                         ArrayRef<Requirement *> Requirements,
+                         SourceLocation ClosingBraceLoc) {
+  return new (Context) RequiresExpr(Context, RequiresKWLoc, Body,
+                                    LocalParameters, Requirements,
+                                    ClosingBraceLoc);
 }
 No newline at end of file

lib/Sema/SemaLookup.cpp

if (Context->isFileContext())
     return S.getOwningModule(Entity);
   return getDefiningModule(S, cast<Decl>(Context));
 }
 
 llvm::DenseSet<Module*> &Sema::getLookupModules() {
   unsigned N = CodeSynthesisContexts.size();
   for (unsigned I = CodeSynthesisContextLookupModules.size();
        I != N; ++I) {
-    Module *M = getDefiningModule(*this, CodeSynthesisContexts[I].Entity);
+    Module *M = CodeSynthesisContexts[I].Entity ?
+                getDefiningModule(*this, CodeSynthesisContexts[I].Entity) :
+                nullptr;
     if (M && !LookupModulesCache.insert(M).second)
       M = nullptr;
     CodeSynthesisContextLookupModules.push_back(M);
   }
   return LookupModulesCache;
 }
 
 bool Sema::hasVisibleMergedDefinition(NamedDecl *Def) {

lib/Sema/SemaTemplateDeduction.cpp

bool hasDeducibleTemplateParameters(Sema &S,
   TemplateParameterList *TemplateParams
     = FunctionTemplate->getTemplateParameters();
   llvm::SmallBitVector Deduced(TemplateParams->size());
   ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
                                Deduced);
 
   return Deduced.any();
 }
+
+QualType Sema::matchTypeByDeduction(TemplateParameterList *TemplateParams,
+                                    QualType ParamType, Expr *Arg) {
+  assert(TemplateParams->size() == 1 &&
+         isa<TemplateTypeParmDecl>(TemplateParams->getParam(0)) &&
+         "Only template parameter lists containing a single type parameter are "
+         "supported");
+  llvm::SmallVector<DeducedTemplateArgument, 1> Deduced;
+  Deduced.resize(1);
+  llvm::SmallVector<OriginalCallArg, 1> OriginalCallArgs;
+  OriginalCallArgs.push_back(OriginalCallArg(ParamType,
+                                             /*DecomposedParam=*/false,
+                                             /*ArgIdx=*/0, Arg->getType()));
+  TemplateDeductionInfo Info{SourceLocation()};
+  auto Result = ::DeduceTemplateArgumentsFromCallArgument(*this, TemplateParams,
+      /*FirstInnerIndex=*/0, ParamType, Arg, Info, Deduced,  OriginalCallArgs,
+      /*DecomposedParam=*/false, /*ArgIdx=*/0, /*TDF=*/0);
+  return Result == TDK_Success ? Deduced[0].getAsType() : QualType();
+}
 No newline at end of file

lib/Sema/SemaTemplateInstantiate.cpp

bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   case ExceptionSpecInstantiation:
   case DefaultTemplateArgumentInstantiation:
   case DefaultFunctionArgumentInstantiation:
   case ExplicitTemplateArgumentSubstitution:
   case DeducedTemplateArgumentSubstitution:
   case PriorTemplateArgumentSubstitution:
     return true;
 
+  case RequirementInstantiation:
   case DefaultTemplateArgumentChecking:
   case DeclaringSpecialMember:
   case DefiningSynthesizedFunction:
     return false;
   }
 
   llvm_unreachable("Invalid SynthesisKind!");
 }
if (!Invalid) {
     Inst.Entity = Entity;
     Inst.Template = Template;
     Inst.TemplateArgs = TemplateArgs.data();
     Inst.NumTemplateArgs = TemplateArgs.size();
     Inst.DeductionInfo = DeductionInfo;
     Inst.InstantiationRange = InstantiationRange;
     SemaRef.pushCodeSynthesisContext(Inst);
 
-    AlreadyInstantiating =
+    AlreadyInstantiating = !Inst.Entity ? false :
         !SemaRef.InstantiatingSpecializations
              .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
              .second;
   }
 }
 
 Sema::InstantiatingTemplate::InstantiatingTemplate(
     Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
Sema::InstantiatingTemplate::InstantiatingTemplate(
     Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
     NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
     SourceRange InstantiationRange)
     : InstantiatingTemplate(
           SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
           PointOfInstantiation, InstantiationRange, Param, Template,
           TemplateArgs) {}
 
+Sema::InstantiatingTemplate::InstantiatingTemplate(
+    Sema &SemaRef, SourceLocation PointOfInstantiation, Requirement *Req,
+    sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
+    : InstantiatingTemplate(
+          SemaRef, CodeSynthesisContext::RequirementInstantiation,
+          PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
+          /*Template=*/nullptr, /*TemplateArgs=*/None, &DeductionInfo) {}
+
 void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
   Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
   InNonInstantiationSFINAEContext = false;
 
   CodeSynthesisContexts.push_back(Ctx);
 
   if (!Ctx.isInstantiationRecord())
     ++NonInstantiationEntries;
void Sema::popCodeSynthesisContext() {
 
   CodeSynthesisContexts.pop_back();
 }
 
 void Sema::InstantiatingTemplate::Clear() {
   if (!Invalid) {
     if (!AlreadyInstantiating) {
       auto &Active = SemaRef.CodeSynthesisContexts.back();
+      if (Active.Entity)
         SemaRef.InstantiatingSpecializations.erase(
             std::make_pair(Active.Entity, Active.Kind));
     }
 
     SemaRef.popCodeSynthesisContext();
 
     Invalid = true;
   }
 }
 
for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
 
     case CodeSynthesisContext::ExceptionSpecInstantiation:
       Diags.Report(Active->PointOfInstantiation,
                    diag::note_template_exception_spec_instantiation_here)
         << cast<FunctionDecl>(Active->Entity)
         << Active->InstantiationRange;
       break;
 
+    case CodeSynthesisContext::RequirementInstantiation:
+      Diags.Report(Active->PointOfInstantiation,
+                   diag::note_template_requirement_instantiation_here)
+        << Active->InstantiationRange;
+      break;
+
     case CodeSynthesisContext::DeclaringSpecialMember:
       Diags.Report(Active->PointOfInstantiation,
                    diag::note_in_declaration_of_implicit_special_member)
         << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
       break;
 
     case CodeSynthesisContext::DefiningSynthesizedFunction:
       // FIXME: For synthesized members other than special members, produce a note.
for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
       // A default template argument instantiation and substitution into
       // template parameters with arguments for prior parameters may or may 
       // not be a SFINAE context; look further up the stack.
       break;
 
     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
-      // We're either substitution explicitly-specified template arguments
-      // or deduced template arguments, so SFINAE applies.
+    case CodeSynthesisContext::RequirementInstantiation:
+      // We're either substituting explicitly-specified template arguments,
+      // or deduced template arguments or a requirement in a requires
+      // expression, so SFINAE applies.
       assert(Active->DeductionInfo && "Missing deduction info pointer");
       return Active->DeductionInfo;
 
     case CodeSynthesisContext::DeclaringSpecialMember:
     case CodeSynthesisContext::DefiningSynthesizedFunction:
       // This happens in a context unrelated to template instantiation, so
       // there is no SFINAE.
       return None;
public:
     QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
                                            SubstTemplateTypeParmPackTypeLoc TL);
 
     ExprResult TransformLambdaExpr(LambdaExpr *E) {
       LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
       return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E);
     }
 
+    ExprResult TransformRequiresExpr(RequiresExpr *E) {
+      LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
+      return TreeTransform<TemplateInstantiator>::TransformRequiresExpr(E);
+    }
+
     TemplateParameterList *TransformTemplateParameterList(
                               TemplateParameterList *OrigTPL)  {
       if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
          
       DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
       TemplateDeclInstantiator  DeclInstantiator(getSema(), 
                         /* DeclContext *Owner */ Owner, TemplateArgs);
       return DeclInstantiator.SubstTemplateParams(OrigTPL); 
     }
+
+    TypeRequirement *TransformTypeRequirement(TypeRequirement *Req);
+    ExprRequirement *TransformExprRequirement(ExprRequirement *Req);
+    NestedRequirement *TransformNestedRequirement(NestedRequirement *Req);
+
   private:
     ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
                                                SourceLocation loc,
                                                TemplateArgument arg);
   };
 }
 
 bool TemplateInstantiator::AlreadyTransformed(QualType T) {
   if (T.isNull())
     return true;
   
   if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
     return false;
   
   getSema().MarkDeclarationsReferencedInType(Loc, T);
   return true;
 }
 
 static TemplateArgument
 getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
   assert(S.ArgumentPackSubstitutionIndex >= 0);        
Result = getSema().Context.getSubstTemplateTypeParmType(
                                       TL.getTypePtr()->getReplacedParameter(),
                                                           Result);
   SubstTemplateTypeParmTypeLoc NewTL
     = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
   return Result;
 }
 
+template<typename EntityPrinter>
+static Requirement::SubstitutionDiagnostic *
+createSubstDiag(Sema &S, TemplateDeductionInfo &Info, EntityPrinter Printer) {
+  const PartialDiagnosticAt &PDA = Info.peekSFINAEDiagnostic();
+  SmallString<128> Message;
+  PDA.second.EmitToString(S.getDiagnostics(), Message);
+  std::string Str;
+  llvm::raw_string_ostream OS(Str);
+  Printer(OS);
+  return new (S.Context) Requirement::SubstitutionDiagnostic{OS.str(),
+                                                             PDA.first,
+                                                             Message.str()};
+}
+
+TypeRequirement *
+TemplateInstantiator::TransformTypeRequirement(TypeRequirement *Req) {
+  if (!Req->isDependent() && !AlwaysRebuild())
+    return Req;
+  if (Req->isSubstitutionFailure()) {
+    if (AlwaysRebuild())
+      return RebuildTypeRequirement(
+              Req->getSubstitutionDiagnostic());
+    return Req;
+  }
+
+  Sema::SFINAETrap Trap(SemaRef);
+  TemplateDeductionInfo Info(Req->getType()->getTypeLoc().getBeginLoc());
+  Sema::InstantiatingTemplate TypeInst(SemaRef,
+      Req->getType()->getTypeLoc().getBeginLoc(), Req, Info,
+      Req->getType()->getTypeLoc().getSourceRange());
+  TypeSourceInfo *TransType = TransformType(Req->getType());
+  if (!TransType)
+    return RebuildTypeRequirement(createSubstDiag(SemaRef, Info,
+        [&] (llvm::raw_string_ostream& OS) {
+            Req->getType()->getType().print(OS, SemaRef.getPrintingPolicy());
+        }));
+  return RebuildTypeRequirement(TransType);
+}
+
+ExprRequirement *
+TemplateInstantiator::TransformExprRequirement(ExprRequirement *Req) {
+  if (!Req->isDependent() && !AlwaysRebuild())
+    return Req;
+
+  Sema::SFINAETrap Trap(SemaRef);
+  TemplateDeductionInfo Info(Req->getExpr()->getLocStart());
+
+  llvm::PointerUnion<Expr *, Requirement::SubstitutionDiagnostic *> TransExpr;
+  if (Req->isExprSubstitutionFailure())
+    TransExpr = Req->getExprSubstitutionDiagnostic();
+  else {
+    Sema::InstantiatingTemplate ExprInst(SemaRef, Req->getExpr()->getLocStart(),
+                                         Req, Info,
+                                         Req->getExpr()->getSourceRange());
+    ExprResult TransExprRes = TransformExpr(Req->getExpr());
+    if (TransExprRes.isInvalid())
+      TransExpr = createSubstDiag(SemaRef, Info,
+          [&] (llvm::raw_string_ostream& OS) {
+              Req->getExpr()->printPretty(OS, nullptr,
+                                          SemaRef.getPrintingPolicy());
+          });
+    else
+      TransExpr = TransExprRes.get();
+  }
+
+  llvm::Optional<ExprRequirement::ReturnTypeRequirement> TransRetReq;
+  const auto &RetReq = Req->getReturnTypeRequirement();
+  if (RetReq.isEmpty())
+    TransRetReq.emplace();
+  else if (RetReq.isSubstitutionFailure())
+    TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
+  else if (RetReq.isTrailingReturnType()) {
+    Sema::InstantiatingTemplate TypeInst(SemaRef, SourceLocation(), Req, Info,
+                                         SourceRange());
+    TypeSourceInfo *TransType = TransformType(
+        RetReq.getTrailingReturnTypeExpectedType());
+    if (!TransType)
+      TransRetReq.emplace(createSubstDiag(SemaRef, Info,
+          [&] (llvm::raw_string_ostream& OS) {
+              RetReq.getTrailingReturnTypeExpectedType()->getType().print(OS,
+                  SemaRef.getPrintingPolicy());
+          }));
+    else
+      TransRetReq.emplace(SemaRef.Context, TransType);
+  } else if (RetReq.isConstrainedParameter()) {
+    TemplateParameterList *OrigTPL =
+        RetReq.getConstrainedParamTemplateParameterList();
+    Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
+                                        Req, Info, OrigTPL->getSourceRange());
+    TemplateParameterList *TPL =
+        TransformTemplateParameterList(OrigTPL);
+    if (!TPL)
+      TransRetReq.emplace(createSubstDiag(SemaRef, Info,
+          [&] (llvm::raw_string_ostream& OS) {
+              OrigTPL->getRequiresClause()->printPretty(OS, nullptr,
+                  SemaRef.getPrintingPolicy());
+          }));
+    else {
+      TPLInst.Clear();
+      Sema::InstantiatingTemplate TypeInst(SemaRef, SourceLocation(), Req, Info,
+                                           SourceRange());
+      TypeSourceInfo *TransType = TransformType(
+          RetReq.getConstrainedParamExpectedType());
+      if (!TransType)
+        TransRetReq.emplace(createSubstDiag(SemaRef, Info,
+            [&] (llvm::raw_string_ostream& OS) {
+                RetReq.getConstrainedParamExpectedType()->getType()
+                    .print(OS, SemaRef.getPrintingPolicy());
+            }));
+      else
+        TransRetReq.emplace(SemaRef.Context, TPL, TransType);
+    }
+  }
+  assert(TransRetReq.hasValue() &&
+         "All code paths leading here must set TransRetReq");
+  if (Expr *E = TransExpr.dyn_cast<Expr *>())
+    return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(),
+                                  std::move(*TransRetReq));
+  return RebuildExprRequirement(
+      TransExpr.get<Requirement::SubstitutionDiagnostic *>(), Req->isSimple(),
+      Req->getNoexceptLoc(), std::move(*TransRetReq));
+}
+
+NestedRequirement *
+TemplateInstantiator::TransformNestedRequirement(NestedRequirement *Req) {
+  if (!Req->isDependent() && !AlwaysRebuild())
+    return Req;
+  if (Req->isSubstitutionFailure()) {
+    if (AlwaysRebuild())
+      return RebuildNestedRequirement(
+          Req->getSubstitutionDiagnostic());
+    return Req;
+  }
+
+  Sema::SFINAETrap Trap(SemaRef);
+  TemplateDeductionInfo Info(Req->getConstraintExpr()->getLocStart());
+
+  Sema::InstantiatingTemplate ConstrInst(SemaRef,
+      Req->getConstraintExpr()->getLocStart(), Req, Info,
+      Req->getConstraintExpr()->getSourceRange());
+  ExprResult TransConstraint = TransformExpr(Req->getConstraintExpr());
+  if (TransConstraint.isInvalid())
+    return RebuildNestedRequirement(createSubstDiag(SemaRef, Info,
+        [&] (llvm::raw_string_ostream& OS) {
+            Req->getConstraintExpr()->printPretty(OS, nullptr,
+                                                  SemaRef.getPrintingPolicy());
+        }));
+  return RebuildNestedRequirement(TransConstraint.get());
+}
+
+
 /// \brief Perform substitution on the type T with a given set of template
 /// arguments.
 ///
 /// This routine substitutes the given template arguments into the
 /// type T and produces the instantiated type.
 ///
 /// \param T the type into which the template arguments will be
 /// substituted. If this type is not dependent, it will be returned

lib/Sema/SemaTemplateInstantiateDecl.cpp

Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
   return nullptr;
 }
 
 Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
   llvm_unreachable("Concept definitions cannot reside inside a template");
   return nullptr;
 }
 
+Decl *
+TemplateDeclInstantiator::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
+  return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(),
+                                      D->getLocStart());
+}
+
 Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
   llvm_unreachable("Unexpected decl");
 }
 
 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
                       const MultiLevelTemplateArgumentList &TemplateArgs) {
   TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
   if (D->isInvalidDecl())

lib/Sema/SemaType.cpp

case Declarator::LambdaExprContext:
       // Declared return type of a lambda-declarator is implicit and is always
       // 'auto'.
       break;
     case Declarator::ObjCParameterContext:
     case Declarator::ObjCResultContext:
     case Declarator::PrototypeContext:
       Error = 0;  
       break;
+    case Declarator::RequiresExprContext:
+      Error = 21;
+      break;
     case Declarator::LambdaExprParameterContext:
       // In C++14, generic lambdas allow 'auto' in their parameters.
       if (!SemaRef.getLangOpts().CPlusPlus14 ||
           !Auto || Auto->getKeyword() != AutoTypeKeyword::Auto)
         Error = 16;
       else {
         // If auto is mentioned in a lambda parameter context, convert it to a 
         // template parameter type.
if (SemaRef.getLangOpts().CPlusPlus &&
     case Declarator::CXXNewContext:
     case Declarator::CXXCatchContext:
     case Declarator::ObjCCatchContext:
     case Declarator::TemplateTypeArgContext:
       DiagID = diag::err_type_defined_in_type_specifier;
       break;
     case Declarator::PrototypeContext:
     case Declarator::LambdaExprParameterContext:
+    case Declarator::RequiresExprContext:
     case Declarator::ObjCParameterContext:
     case Declarator::ObjCResultContext:
     case Declarator::KNRTypeListContext:
       // C++ [dcl.fct]p6:
       //   Types shall not be defined in return or parameter types.
       DiagID = diag::err_type_defined_in_param_type;
       break;
     case Declarator::ConditionContext:
if (IsTypedefName) {
     case Declarator::InitStmtContext:
     case Declarator::LambdaExprContext:
     case Declarator::LambdaExprParameterContext:
     case Declarator::ObjCCatchContext:
     case Declarator::TemplateParamContext:
     case Declarator::TemplateTypeArgContext:
     case Declarator::TypeNameContext:
     case Declarator::FunctionalCastContext:
+    case Declarator::RequiresExprContext:
       // Don't infer in these contexts.
       break;
     }
   }
 
   // Local function that returns true if its argument looks like a va_list.
   auto isVaList = [&S](QualType T) -> bool {
     auto *typedefTy = T->getAs<TypedefType>();

   if (D.hasEllipsis()) {
     // C++0x [dcl.fct]p13:
     //   A declarator-id or abstract-declarator containing an ellipsis shall
     //   only be used in a parameter-declaration. Such a parameter-declaration
     //   is a parameter pack (14.5.3). [...]
     switch (D.getContext()) {
     case Declarator::PrototypeContext:
     case Declarator::LambdaExprParameterContext:
+    case Declarator::RequiresExprContext:
       // C++0x [dcl.fct]p13:
       //   [...] When it is part of a parameter-declaration-clause, the
       //   parameter pack is a function parameter pack (14.5.3). The type T
       //   of the declarator-id of the function parameter pack shall contain
       //   a template parameter pack; each template parameter pack in T is
       //   expanded by the function parameter pack.
       //
       // We represent function parameter packs as function parameters whose

lib/Sema/TreeTransform.h

#include "clang/Basic/AttrList.inc"
   ///
   /// By default, transforms the types of conversion function, constructor,
   /// and destructor names and then (if needed) rebuilds the declaration name.
   /// Identifiers and selectors are returned unmodified. Sublcasses may
   /// override this function to provide alternate behavior.
   DeclarationNameInfo
   TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
 
+  TypeRequirement *TransformTypeRequirement(TypeRequirement *Req);
+  ExprRequirement *TransformExprRequirement(ExprRequirement *Req);
+  NestedRequirement *TransformNestedRequirement(NestedRequirement *Req);
+
   /// \brief Transform the given template name.
   ///
   /// \param SS The nested-name-specifier that qualifies the template
   /// name. This nested-name-specifier must already have been transformed.
   ///
   /// \param Name The template name to transform.
   ///
   /// \param NameLoc The source location of the template name.
ExprResult RebuildConceptSpecializationExpr(SourceLocation ConceptNameLoc,
     ExprResult Result
             = getSema().CreateConceptSpecializationExpr(ConceptNameLoc, CTD,
                                                         TALI);
     if (Result.isInvalid())
       return ExprError();
     return Result;
   }
 
-    /// \brief Build a new Objective-C boxed expression.
+  /// \brief Build a new requires expression.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
+                                 RequiresExprBodyDecl *Body,
+                                 ArrayRef<ParmVarDecl *> LocalParameters,
+                                 ArrayRef<Requirement *> Requirements,
+                                 SourceLocation ClosingBraceLoc) {
+    ExprResult Result = getSema().CreateRequiresExpr(RequiresKWLoc, Body,
+                                                     LocalParameters,
+                                                     Requirements,
+                                                     ClosingBraceLoc);
+    if (Result.isInvalid())
+      return ExprError();
+    return Result;
+  }
+
+  TypeRequirement *
+  RebuildTypeRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) {
+    return new (SemaRef.Context) TypeRequirement(SubstDiag);
+  }
+
+  TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) {
+    return new (SemaRef.Context) TypeRequirement(T);
+  }
+
+  ExprRequirement *
+  RebuildExprRequirement(Requirement::SubstitutionDiagnostic *SubstDiag,
+                         bool IsSimple, SourceLocation NoexceptLoc,
+                         ExprRequirement::ReturnTypeRequirement Ret) {
+    return new (SemaRef.Context) ExprRequirement(SubstDiag, IsSimple,
+                                                 NoexceptLoc, std::move(Ret));
+  }
+
+  ExprRequirement *
+  RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
+                         ExprRequirement::ReturnTypeRequirement Ret) {
+    return new (SemaRef.Context) ExprRequirement(SemaRef, E, IsSimple,
+                                                 NoexceptLoc, std::move(Ret));
+  }
+
+  NestedRequirement *
+  RebuildNestedRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) {
+    return new (SemaRef.Context) NestedRequirement(SubstDiag);
+  }
+
+  NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
+    return new (SemaRef.Context) NestedRequirement(SemaRef, Constraint);
+  }
+
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
     return getSema().BuildObjCBoxedExpr(SR, ValueExpr);
   }
 
   /// \brief Build a new Objective-C array literal.
if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
                                               Old->NumTemplateArgs, TransArgs))
     return ExprError();
 
   return getDerived().RebuildConceptSpecializationExpr(E->getConceptNameLoc(),
                                                        E->getNamedConcept(),
                                                        &TransArgs);
 }
 
+template<typename Derived>
+ExprResult
+TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
+  SmallVector<ParmVarDecl*, 4> TransParams;
+  SmallVector<QualType, 4> TransParamTypes;
+  Sema::ExtParameterInfoBuilder ExtParamInfos;
+
+  // C++2a [expr.prim.req]p2
+  // Expressions appearing within a requirement-body are unevaluated operands.
+  EnterExpressionEvaluationContext Ctx(
+      SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
+
+  RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
+      getSema().Context, E->getBody()->getDeclContext(),
+      E->getBody()->getLocStart());
+
+  if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(),
+                                               E->getLocalParameters(),
+                                               /*ParamTypes=*/nullptr,
+                                               /*ParamInfos=*/nullptr,
+                                               TransParamTypes, &TransParams,
+                                               ExtParamInfos))
+    return ExprError();
+
+  for (ParmVarDecl *Param : TransParams)
+    Param->setDeclContext(Body);
+
+  llvm::SmallVector<Requirement *, 4> TransReqs;
+  for (Requirement *Req : E->getRequirements()) {
+    Requirement *TransReq = nullptr;
+    if (auto *TypeReq = dyn_cast<TypeRequirement>(Req))
+      TransReq = getDerived().TransformTypeRequirement(TypeReq);
+    else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req)) {
+      TransReq = getDerived().TransformExprRequirement(ExprReq);
+      if (TransReq) {
+        auto *R = cast<ExprRequirement>(TransReq);
+        if (R->getReturnTypeRequirement().isConstrainedParameter())
+          R->getReturnTypeRequirement()
+              .getConstrainedParamTemplateParameterList()->getParam(0)
+              ->setDeclContext(Body);
+      }
+    } else
+      TransReq = getDerived().TransformNestedRequirement(
+                     cast<NestedRequirement>(Req));
+    if (!TransReq)
+      return ExprError();
+    TransReqs.push_back(TransReq);
+  }
+
+  return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
+                                          TransParams, TransReqs,
+                                          E->getRBraceLoc());
+}
+
+template<typename Derived>
+TypeRequirement *
+TreeTransform<Derived>::TransformTypeRequirement(TypeRequirement *Req) {
+  if (Req->isSubstitutionFailure()) {
+    if (getDerived().AlwaysRebuild())
+      return getDerived().RebuildTypeRequirement(
+              Req->getSubstitutionDiagnostic());
+    return Req;
+  }
+  TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
+  if (!TransType)
+    return nullptr;
+  return getDerived().RebuildTypeRequirement(TransType);
+}
+
+template<typename Derived>
+ExprRequirement *
+TreeTransform<Derived>::TransformExprRequirement(ExprRequirement *Req) {
+  llvm::PointerUnion<Expr *, Requirement::SubstitutionDiagnostic *> TransExpr;
+  if (Req->isExprSubstitutionFailure())
+    TransExpr = Req->getExprSubstitutionDiagnostic();
+  else {
+    ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
+    if (TransExprRes.isInvalid())
+      return nullptr;
+    TransExpr = TransExprRes.get();
+  }
+
+  llvm::Optional<ExprRequirement::ReturnTypeRequirement> TransRetReq;
+  const auto &RetReq = Req->getReturnTypeRequirement();
+  if (RetReq.isEmpty())
+    TransRetReq.emplace();
+  else if (RetReq.isSubstitutionFailure())
+    TransRetReq.emplace(RetReq.getSubstitutionDiagnostic());
+  else if (RetReq.isTrailingReturnType()) {
+    TypeSourceInfo *TransType = getDerived().TransformType(
+        RetReq.getTrailingReturnTypeExpectedType());
+    if (!TransType)
+      return nullptr;
+    TransRetReq.emplace(getSema().Context, TransType);
+  } else if (RetReq.isConstrainedParameter()) {
+    TemplateParameterList *OrigTPL =
+        RetReq.getConstrainedParamTemplateParameterList();
+    TemplateParameterList *TPL =
+        getDerived().TransformTemplateParameterList(OrigTPL);
+    if (!TPL)
+      return nullptr;
+
+    TypeSourceInfo *TransType = getDerived().TransformType(
+        RetReq.getConstrainedParamExpectedType());
+    if (!TransType)
+      return nullptr;
+    TransRetReq.emplace(getSema().Context, TPL, TransType);
+  }
+  assert(TransRetReq.hasValue() &&
+         "All code paths leading here must set TransRetReq");
+  if (Expr *E = TransExpr.dyn_cast<Expr *>())
+    return getDerived().RebuildExprRequirement(E, Req->isSimple(),
+                                               Req->getNoexceptLoc(),
+                                               std::move(*TransRetReq));
+  return getDerived().RebuildExprRequirement(
+      TransExpr.get<Requirement::SubstitutionDiagnostic *>(), Req->isSimple(),
+      Req->getNoexceptLoc(), std::move(*TransRetReq));
+}
+
+template<typename Derived>
+NestedRequirement *
+TreeTransform<Derived>::TransformNestedRequirement(NestedRequirement *Req) {
+  if (Req->isSubstitutionFailure()) {
+    if (getDerived().AlwaysRebuild())
+      return getDerived().RebuildNestedRequirement(
+          Req->getSubstitutionDiagnostic());
+    return Req;
+  }
+  ExprResult TransConstraint =
+      getDerived().TransformExpr(Req->getConstraintExpr());
+  if (TransConstraint.isInvalid())
+    return nullptr;
+  return getDerived().RebuildNestedRequirement(TransConstraint.get());
+}
 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
   TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
   if (!T)
     return ExprError();
 

lib/Serialization/ASTCommon.cpp

bool serialization::isRedeclarableDeclKind(unsigned Kind) {
   case Decl::Import:
   case Decl::OMPThreadPrivate:
   case Decl::OMPCapturedExpr:
   case Decl::OMPDeclareReduction:
   case Decl::BuiltinTemplate:
   case Decl::Decomposition:
   case Decl::Binding:
   case Decl::Concept:
+  case Decl::RequiresExprBody:
     return false;
 
   // These indirectly derive from Redeclarable<T> but are not actually
   // redeclarable.
   case Decl::ImplicitParam:
   case Decl::ParmVar:
   case Decl::ObjCTypeParam:
     return false;

lib/Serialization/ASTReaderStmt.cpp

if (Record.peekInt() == 0) {
     Record.skipInts(1);
   } else {
     E->setArgument(GetTypeSourceInfo());
   }
   E->setOperatorLoc(ReadSourceLocation());
   E->setRParenLoc(ReadSourceLocation());
 }
 
-void ASTStmtReader::VisitConceptSpecializationExpr(
-        ConceptSpecializationExpr *E) {
-  VisitExpr(E);
-  E->setNamedConcept(ReadDeclAs<ConceptDecl>());
-  E->setConceptNameLoc(Record.readSourceLocation());
-  const ASTTemplateArgumentListInfo *Info =
-      Record.readASTTemplateArgumentListInfo();
-  TemplateArgumentListInfo TALI(Info->LAngleLoc, Info->RAngleLoc);
-  for (const TemplateArgumentLoc &Arg : Info->arguments())
-    TALI.addArgument(Arg);
-  E->setTemplateArguments(Record.getContext(), /*Sema=*/nullptr, &TALI);
+static ConstraintSatisfaction
+readConstraintSatisfaction(ASTRecordReader &Record) {
   ConstraintSatisfaction Satisfaction;
   Satisfaction.IsSatisfied = Record.readInt();
   if (!Satisfaction.IsSatisfied) {
     unsigned NumDetailRecords = Record.readInt();
     for (unsigned i = 0; i != NumDetailRecords; ++i) {
       Expr *ConstraintExpr = Record.readExpr();
-      bool IsDiagnostic = Record.readInt();
-      if (IsDiagnostic) {
+      if (bool IsDiagnostic = Record.readInt()) {
         SourceLocation DiagLocation = Record.readSourceLocation();
         std::string DiagMessage = Record.readString();
         Satisfaction.Details.emplace_back(
             ConstraintExpr, new (Record.getContext())
                                 ConstraintSatisfaction::SubstitutionDiagnostic{
                                     DiagLocation, DiagMessage});
       } else
         Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr());
     }
   }
+  return Satisfaction;
+}
+
+void ASTStmtReader::VisitConceptSpecializationExpr(
+        ConceptSpecializationExpr *E) {
+  VisitExpr(E);
+  E->setNamedConcept(ReadDeclAs<ConceptDecl>());
+  E->setConceptNameLoc(Record.readSourceLocation());
+
+  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(Record.getContext(), /*Sema=*/nullptr, &ArgInfo);
+  E->setSatisfaction(readConstraintSatisfaction(Record));
+}
+
+static Requirement::SubstitutionDiagnostic *
+readSubstitutionDiagnostic(ASTRecordReader &Record) {
+  std::string SubstitutedEntity = Record.readString();
+  SourceLocation DiagLoc = Record.readSourceLocation();
+  std::string DiagMessage = Record.readString();
+  return new (Record.getContext()) Requirement::SubstitutionDiagnostic{
+                                    SubstitutedEntity, DiagLoc, DiagMessage};
+}
+
+void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
+  VisitExpr(E);
+  SourceLocation RequiresKWLoc = Record.readSourceLocation();
+  E->setRequiresKWLoc(RequiresKWLoc);
+  auto *Body = cast<RequiresExprBodyDecl>(Record.readDecl());
+  E->setBody(Body);
+  unsigned NumLocalParameters = Record.readInt();
+  llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
+  for (unsigned i = 0; i < NumLocalParameters; ++i)
+    LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
+  E->setLocalParameters(LocalParameters);
+  unsigned NumRequirements = Record.readInt();
+  llvm::SmallVector<Requirement *, 4> Requirements;
+  for (unsigned i = 0; i < NumRequirements; ++i) {
+    auto RK = static_cast<Requirement::RequirementKind>(Record.readInt());
+    Requirement *R = nullptr;
+    switch (RK) {
+      case Requirement::RK_Type: {
+        auto Status =
+            static_cast<TypeRequirement::SatisfactionStatus>(Record.readInt());
+        if (Status == TypeRequirement::SS_SubstitutionFailure)
+          R = new (Record.getContext()) TypeRequirement(
+              readSubstitutionDiagnostic(Record));
+        else
+          R = new (Record.getContext()) TypeRequirement(
+              Record.getTypeSourceInfo());
+      } break;
+      case Requirement::RK_Simple:
+      case Requirement::RK_Compound: {
+        auto Status =
+            static_cast<ExprRequirement::SatisfactionStatus >(Record.readInt());
+        llvm::PointerUnion<Requirement::SubstitutionDiagnostic *,
+                           Expr *> E;
+        if (Status == ExprRequirement::SS_ExprSubstitutionFailure) {
+          E = readSubstitutionDiagnostic(Record);
+        } else
+          E = Record.readExpr();
+
+        llvm::Optional<ExprRequirement::ReturnTypeRequirement> Req;
+        SourceLocation NoexceptLoc;
+        if (RK == Requirement::RK_Simple) {
+          Req.emplace();
+        } else {
+          NoexceptLoc = Record.readSourceLocation();
+          switch (auto returnTypeRequirementKind = Record.readInt()) {
+            case 0:
+              // No return type requirement.
+              Req.emplace();
+              break;
+            case 1: {
+              // trailing-return-type
+              TypeSourceInfo *ExpectedType = Record.getTypeSourceInfo();
+              Req.emplace(Record.getContext(), ExpectedType);
+            } break;
+            case 2: {
+              // Constrained parameter
+              TypeSourceInfo *ExpectedType = Record.getTypeSourceInfo();
+              TemplateParameterList *TPL = Record.readTemplateParameterList();
+              ConceptSpecializationExpr *CSE = nullptr;
+              if (Status >= ExprRequirement::SS_ConstraintsNotSatisfied)
+                CSE = cast<ConceptSpecializationExpr>(Record.readExpr());
+              if (CSE)
+                Req.emplace(Record.getContext(), TPL, ExpectedType, CSE);
+            } break;
+            case 3: {
+              // Substitution failure
+              Req.emplace(readSubstitutionDiagnostic(Record));
+            } break;
+          }
+        }
+        if (Req) {
+          if (Expr *Ex = E.dyn_cast<Expr *>())
+            R = new (Record.getContext()) ExprRequirement(Ex,
+                    RK == Requirement::RK_Simple, NoexceptLoc, std::move(*Req),
+                    Status);
+          else
+            R = new (Record.getContext()) ExprRequirement(
+                    E.get<Requirement::SubstitutionDiagnostic *>(),
+                    RK == Requirement::RK_Simple, NoexceptLoc, std::move(*Req));
+        }
+      } break;
+      case Requirement::RK_Nested: {
+        if (bool IsSubstitutionDiagnostic = Record.readInt()) {
+          SourceLocation SubstDiagLocation = Record.readSourceLocation();
+          std::string SubstDiagMessage = Record.readString();
+          R = new (Record.getContext()) NestedRequirement(
+              readSubstitutionDiagnostic(Record));
+          break;
+        }
+        Expr *E = Record.readExpr();
+        if (E->isInstantiationDependent())
+          R = new (Record.getContext()) NestedRequirement(E);
+        else
+          R = new (Record.getContext()) NestedRequirement(E,
+                  readConstraintSatisfaction(Record));
+      } break;
+    }
+    if (!R)
+      continue;
+    Requirements.push_back(R);
+  }
+  E->setRequirements(Requirements);
+  SourceLocation RBraceLoc = Record.readSourceLocation();
+  E->setRBraceLoc(RBraceLoc);
 }
 
 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
   E->setLHS(Record.readSubExpr());
   E->setRHS(Record.readSubExpr());
   E->setRBracketLoc(ReadSourceLocation());
 }
while (true) {
 
     case EXPR_DEPENDENT_COAWAIT:
       S = new (Context) DependentCoawaitExpr(Empty);
       break;
 
     case EXPR_CONCEPT_SPECIALIZATION:
       S = new (Context) ConceptSpecializationExpr(Context, Empty);
       break;
+
+    case EXPR_REQUIRES:
+      S = new (Context) RequiresExpr(Context, Empty);
+      break;
     }
 
     // We hit a STMT_STOP, so we're done with this expression.
     if (Finished)
       break;
 
     ++NumStatementsRead;
 

lib/Serialization/ASTWriterStmt.cpp

 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements serialization for Statements and Expressions.
 ///
 //===----------------------------------------------------------------------===//
 
+#include <clang/Sema/DeclSpec.h>
 #include "clang/Serialization/ASTWriter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Lex/Token.h"
 #include "llvm/Bitcode/BitstreamWriter.h"

 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getKeywordLoc());
   for (Stmt *S : E->children())
     Record.AddStmt(S);
   Code = serialization::EXPR_DEPENDENT_COAWAIT;
 }
 
-void ASTStmtWriter::VisitConceptSpecializationExpr(
-        ConceptSpecializationExpr *E) {
-  VisitExpr(E);
-  Record.AddDeclRef(E->getNamedConcept());
-  Record.AddSourceLocation(E->getConceptNameLoc());
-  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgumentListInfo());
-  const ConstraintSatisfaction &Satisfaction = E->getSatisfaction();
+static void
+addConstraintSatisfaction(ASTRecordWriter &Record,
+                          const ConstraintSatisfaction &Satisfaction) {
   Record.push_back(Satisfaction.IsSatisfied);
   if (!Satisfaction.IsSatisfied) {
     Record.push_back(Satisfaction.Details.size());
     for (const auto &DetailRecord : Satisfaction.Details) {
       Record.AddStmt(const_cast<Expr *>(DetailRecord.first));
       auto *Diag =
           DetailRecord.second
               .dyn_cast<ConstraintSatisfaction::SubstitutionDiagnostic *>();
       Record.push_back(Diag != nullptr);
       if (Diag) {
         Record.AddSourceLocation(Diag->first);
         Record.AddString(Diag->second);
       } else
         Record.AddStmt(DetailRecord.second.get<Expr *>());
     }
   }
+}
+
+static void
+addSubstitutionDiagnostic(ASTRecordWriter &Record,
+                          const Requirement::SubstitutionDiagnostic *D) {
+  Record.AddString(D->SubstitutedEntity);
+  Record.AddSourceLocation(D->DiagLoc);
+  Record.AddString(D->DiagMessage);
+}
+
+void ASTStmtWriter::VisitConceptSpecializationExpr(
+        ConceptSpecializationExpr *E) {
+  VisitExpr(E);
+  Record.AddDeclRef(E->getNamedConcept());
+  Record.AddSourceLocation(E->getConceptNameLoc());
+  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgumentListInfo());
+
+  addConstraintSatisfaction(Record, E->getSatisfaction());
 
   Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
 }
 
+void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
+  VisitExpr(E);
+  Record.AddSourceLocation(E->getRequiresKWLoc());
+  Record.AddDeclRef(E->getBody());
+  Record.push_back(E->getLocalParameters().size());
+  for (ParmVarDecl *P : E->getLocalParameters())
+    Record.AddDeclRef(P);
+  Record.push_back(E->getRequirements().size());
+  for (Requirement *R : E->getRequirements()) {
+    if (auto *TypeReq = dyn_cast<TypeRequirement>(R)) {
+      Record.push_back(Requirement::RK_Type);
+      Record.push_back(TypeReq->Status);
+      if (TypeReq->Status == TypeRequirement::SS_SubstitutionFailure)
+        addSubstitutionDiagnostic(Record, TypeReq->getSubstitutionDiagnostic());
+      else
+        Record.AddTypeSourceInfo(TypeReq->getType());
+    } else if (auto *ExprReq = dyn_cast<ExprRequirement>(R)) {
+      Record.push_back(ExprReq->getKind());
+      Record.push_back(ExprReq->Status);
+      if (ExprReq->isExprSubstitutionFailure()) {
+        addSubstitutionDiagnostic(Record,
+            ExprReq->Value.get<Requirement::SubstitutionDiagnostic *>());
+      } else
+        Record.AddStmt(ExprReq->Value.get<Expr *>());
+      if (ExprReq->getKind() == Requirement::RK_Compound) {
+        Record.AddSourceLocation(ExprReq->NoexceptLoc);
+        const auto &RetReq = ExprReq->getReturnTypeRequirement();
+        if (RetReq.isSubstitutionFailure()) {
+          Record.push_back(3);
+          addSubstitutionDiagnostic(Record, RetReq.getSubstitutionDiagnostic());
+        } else if (RetReq.isTrailingReturnType()) {
+          Record.push_back(1);
+          Record.AddTypeSourceInfo(RetReq.getTrailingReturnTypeExpectedType());
+        } else if (RetReq.isConstrainedParameter()) {
+          Record.push_back(2);
+          Record.AddTypeSourceInfo(RetReq.getConstrainedParamExpectedType());
+          Record.AddTemplateParameterList(
+              RetReq.getConstrainedParamTemplateParameterList());
+          if (ExprReq->Status >= ExprRequirement::SS_ConstraintsNotSatisfied)
+            Record.AddStmt(
+                std::get<2>(*RetReq.Value.get<ExprRequirement::
+                                              ReturnTypeRequirement::
+                                              ConstrainedParam *>()));
+        } else {
+          assert(RetReq.isEmpty());
+          Record.push_back(0);
+        }
+      }
+    } else {
+      auto *NestedReq = cast<NestedRequirement>(R);
+      Record.push_back(Requirement::RK_Nested);
+
+      if (auto *SubstDiag =
+            NestedReq->Value.dyn_cast<Requirement::SubstitutionDiagnostic *>()){
+        addSubstitutionDiagnostic(Record, SubstDiag);
+      } else {
+        Record.AddStmt(NestedReq->Value.get<Expr *>());
+        if (!NestedReq->isDependent())
+          addConstraintSatisfaction(Record, NestedReq->Satisfaction);
+      }
+    }
+  }
+  Record.AddSourceLocation(E->getLocEnd());
+
+  Code = serialization::EXPR_REQUIRES;
+}
+
 
 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
   // NumCaptures
   Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
 
   // CapturedDecl and captured region kind
   Record.AddDeclRef(S->getCapturedDecl());

lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::ParenListExprClass:
     case Stmt::ShuffleVectorExprClass:
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::ConceptSpecializationExprClass:
+    case Stmt::RequiresExprClass:
       // Fall through.
 
     // Cases we intentionally don't evaluate, since they don't need
     // to be explicitly evaluated.
     case Stmt::PredefinedExprClass:
     case Stmt::AddrLabelExprClass:
     case Stmt::AttributedStmtClass:
     case Stmt::IntegerLiteralClass:

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/compound-requirement.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+static_assert(requires { { 0 }; });
+static_assert(requires { { "aaaa" }; });
+static_assert(requires { { (0).da }; }); // expected-error{{member reference base type 'int' is not a structure or union}}
+
+void foo() {}
+static_assert(requires { { foo() }; });
+
+// Substitution failure in expression
+
+struct A {};
+struct B {
+    B operator+(const B &other) const { return other; }
+};
+struct C {
+    C operator+(C &other) const { return other; }
+};
+
+template<typename T> requires requires (T a, const T& b) { { a + b }; } // expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('A' and 'const A')}} expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('C' and 'const C')}}
+struct r1 {};
+
+using r1i1 = r1<int>;
+using r1i2 = r1<A>; // expected-error{{constraints not satisfied for class template 'r1' [with T = A]}}
+using r1i3 = r1<B>;
+using r1i4 = r1<C>; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}}
+
+struct D { void foo() {} };
+
+template<typename T> requires requires (T a) { { a.foo() }; } // expected-note{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}} expected-note{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}} expected-note{{because 'a.foo()' would be invalid: member function 'foo' not viable: 'this' argument has type 'const D', but function is not marked const}}
+struct r2 {};
+
+using r2i1 = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
+using r2i2 = r2<A>; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}}
+using r2i3 = r2<D>;
+using r2i4 = r2<const D>; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}}
+
+template<typename T> requires requires { { sizeof(T) }; } // expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}}
+struct r3 {};
+
+using r3i1 = r3<int>;
+using r3i2 = r3<A>;
+using r3i3 = r3<A &>;
+using r3i4 = r3<void>; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}}
+using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}}
+
+// Non-dependent expressions
+
+template<typename T> requires requires (T t) { { 0 }; { "a" }; { (void)'a' }; }
+struct r4 {};
+
+using r4i1 = r4<int>;
+using r4i2 = r4<int[10]>;
+using r4i3 = r4<int(int)>;
+
+// Noexcept requirement
+void maythrow() { }
+static_assert(!requires { { maythrow() } noexcept; });
+static_assert(requires { { 1 } noexcept; });
+
+struct E { void operator++(int) noexcept; };
+struct F { void operator++(int); };
+
+template<typename T> requires requires (T t) { { t++ } noexcept; } // expected-note{{because 't ++' may throw an exception}}
+struct r5 {};
+
+using r5i1 = r5<int>;
+using r5i2 = r5<E>;
+using r5i2 = r5<F>; // expected-error{{constraints not satisfied for class template 'r5' [with T = F]}}
+
+template<typename T> requires requires (T t) { { t.foo() } noexcept; } // expected-note{{because 't.foo()' would be invalid: no member named 'foo' in 'E'}}
+struct r6 {};
+
+using r6i = r6<E>; // expected-error{{constraints not satisfied for class template 'r6' [with T = E]}}
+
+// Trailing return type requirement.
+
+static_assert(requires { { 0 } -> int; { 0 } -> const int; { 0 } -> long long int; });
+static_assert(!requires { { 0 } -> void; });
+static_assert(!requires { { 0 } -> char[4]; });
+
+struct G { operator F() { return F(); } G(F) {} };
+struct H { explicit operator F() { return F(); } };
+struct I {
+    operator F() { return F(); }
+    explicit operator F() const { return F(); }
+};
+struct J { operator int() { } operator double() { } };
+
+template<typename T, typename U> requires requires (T t) { { t } -> U; } // expected-note{{because expression type 'int' not implicitly convertible to required type 'void'}} expected-note{{because expression type 'H' not implicitly convertible to required type 'F'}} expected-note{{because expression type 'const I' not implicitly convertible to required type 'F'}} expected-note{{because conversion from expression type 'J' to required type 'long' is ambiguous}}
+struct r7 {};
+
+using r7i1 = r7<int, char>;
+using r7i2 = r7<int, void>; // expected-error{{constraints not satisfied for class template 'r7' [with T = int, U = void]}}
+using r7i3 = r7<G, F>;
+using r7i4 = r7<H, F>; // expected-error{{constraints not satisfied for class template 'r7' [with T = H, U = F]}}
+using r7i5 = r7<F, G>;
+using r7i6 = r7<I, F>;
+using r7i7 = r7<I, const F>;
+using r7i8 = r7<const I, F>; // expected-error{{constraints not satisfied for class template 'r7' [with T = const I, U = F]}}
+using r7i9 = r7<J, long int>; // expected-error{{constraints not satisfied for class template 'r7' [with T = J, U = long]}}
+
+struct K { void foo() { } };
+struct L { int foo() { } };
+
+template<typename T> requires requires (T t) { { t.foo() } -> void; } // expected-note{{because expression type 'int' not implicitly convertible to required type 'void'}}
+struct r8 {};
+
+using r8i1 = r8<K>;
+using r8i2 = r8<L>; // expected-error{{constraints not satisfied for class template 'r8' [with T = L]}}
+
+// Substitution failure in return type requirement
+
+struct M { using type = M; };
+
+template<typename T> requires requires (T t) { { t } -> typename T::type; } // expected-note{{because 'typename T::type' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+struct r9 {};
+
+using r9i1 = r9<M>;
+using r9i2 = r9<int>; // expected-error{{constraints not satisfied for class template 'r9' [with T = int]}}
+
+// Constrained parameter
+
+template<typename T, typename U>
+constexpr bool is_same_v = false;
+
+template<typename T>
+constexpr bool is_same_v<T, T> = true;
+
+template<typename T, typename U>
+concept Same = is_same_v<T, U>;
+
+template<typename T>
+concept Large = sizeof(T) >= 4; // expected-note{{because 'sizeof(short) >= 4' (2 >= 4) evaluated to false}}
+
+template<typename T> requires requires (T t) { { t } -> Large; } // expected-note{{because expression type 'short' does not satisfy 'Large':}}
+struct r10 {};
+
+using r10i1 = r10<int>;
+using r10i2 = r10<short>; // expected-error{{constraints not satisfied for class template 'r10' [with T = short]}}
+
+template<typename T> requires requires (T t) { { t } -> Same<T>; }
+struct r11 {};
+
+using r11i1 = r11<int>;
+using r11i2 = r11<short*>;
+
+template<typename T, typename U> requires requires (T t) { { t } -> const Same<U>*; } // expected-note{{because expression type 'const int' does not match given pattern 'const <type> *'}}
+struct r12 {};
+
+using r12i1 = r12<const int, int>; // expected-error{{constraints not satisfied for class template 'r12' [with T = const int, U = int]}}
+using r12i2 = r12<M*, M>;
+using r12i3 = r12<const M*, M>;
+
+template<typename T, typename U> requires requires (T t) { { t } -> const Same<U> volatile; }
+struct r13 {};
+
+using r13i2 = r13<const int volatile, int>;
+using r13i3 = r13<const M volatile, M>;
+using r13i4 = r13<M const volatile, M>;
+
+template<typename T, typename U> requires requires (T t) { { t } -> Same<U>**; } // expected-note{{because expression type 'const short *' does not match given pattern '<type> **'}}
+struct r14 {};
+
+using r14i1 = r14<const short***, const short*>;
+using r14i2 = r14<const short*, const short*>; // expected-error{{constraints not satisfied for class template 'r14' [with T = const short *, U = const short *]}}
+
+// Substitution failure in constrained parameter
+
+template<typename T> requires requires (T t) { { t } -> Same<typename T::type>; } // expected-note{{because 'Same<expr-type, typename T::type>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+struct r15 {};
+
+using r15i1 = r15<M>;
+using r15i2 = r15<int>; // expected-error{{constraints not satisfied for class template 'r15' [with T = int]}}
+
+// Substitution failure in both expression and return type requirement
+
+template<typename T> requires requires (T t) { { t.foo() } -> Same<typename T::type>; } // expected-note{{because 't.foo()' would be invalid: member reference base type 'int' is not a structure or union}}
+struct r16 {};
+
+using r16i = r16<int>; // expected-error{{constraints not satisfied for class template 'r16' [with T = int]}}
+
+template<typename T> requires requires (T t) { { t.foo() } -> typename T::type; } // expected-note{{because 't.foo()' would be invalid: member reference base type 'int' is not a structure or union}}
+struct r17 {};
+
+using r17i = r17<int>; // expected-error{{constraints not satisfied for class template 'r17' [with T = int]}}
+
+// Non-type concept in constrained parameter
+
+template<int T>
+concept IsEven = (T % 2) == 0;
+
+template<typename T> requires requires (T t) { { t } -> IsEven; } // expected-error{{only type concepts can be used to constrain the type of an expression ('IsEven' is a value concept)}}
+struct r18 {};
+
+// C++ [expr.prim.req.compound] Example
+namespace std_example {
+  template<typename T> concept C1 =
+    requires(T x) {
+      {x++};
+    };
+
+  static_assert(C1<int>);
+  static_assert(C1<int*>);
+  template<C1 T> struct C1_check {};
+  using c1c1 = C1_check<int>;
+  using c1c2 = C1_check<int[10]>;
+
+  template<typename T> concept C2 =
+    requires(T x) {
+      {*x} -> typename T::inner; // expected-note{{because '*x' would be invalid: indirection requires pointer operand ('int' invalid)}} expected-note{{because expression type 'int' not implicitly convertible to required type 'typename T2::inner' (aka 'int *')}}
+    };
+
+  struct T1 {
+    using inner = int;
+    inner operator *() { return 0; }
+  };
+  struct T2 {
+    using inner = int *;
+    int operator *() { return 0; }
+  };
+  static_assert(C2<T1>);
+  template<C2 T> struct C2_check {}; // expected-note{{because 'int' does not satisfy 'C2'}} expected-note{{because 'std_example::T2' does not satisfy 'C2'}}
+  using c2c1 = C2_check<int>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = int]}}
+  using c2c2 = C2_check<T2>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::T2]}}
+
+  template<typename T, typename U> concept C3 = false; // expected-note 2{{because 'false' evaluated to false}}
+  template<typename T> concept C4 =
+    requires(T x) {
+      {*x} -> C3<int> const&; // expected-note{{because '*x' would be invalid: indirection requires pointer operand ('int' invalid)}} expected-note {{because type constraint 'C3<int, int>' was not satisfied:}} expected-note {{because type constraint 'C3<short, int>' was not satisfied:}}
+    };
+
+  struct T3 {
+    short i;
+    const short &operator *() { return i; }
+  };
+
+  template<C4 T> struct C4_check {}; // expected-note{{because 'int' does not satisfy 'C4'}} expected-note{{because 'int *' does not satisfy 'C4'}} expected-note{{because 'std_example::T3' does not satisfy 'C4'}}
+  using c4c1 = C4_check<int>; // expected-error{{constraints not satisfied for class template 'C4_check' [with T = int]}}
+  using c4c2 = C4_check<int *>; // expected-error{{constraints not satisfied for class template 'C4_check' [with T = int *]}}
+  using c4c3 = C4_check<T3>; // expected-error{{constraints not satisfied for class template 'C4_check' [with T = std_example::T3]}}
+
+  template<typename T> concept C5 =
+    requires(T x) {
+      {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}}
+    };
+
+  template<typename T>
+  void g(T t) noexcept(sizeof(T) == 1) {}
+
+  static_assert(C5<char>);
+  template<C5 T> struct C5_check {}; // expected-note{{because 'short' does not satisfy 'C5'}}
+  using c5 = C5_check<short>; // expected-error{{constraints not satisfied for class template 'C5_check' [with T = short]}}
+}
 No newline at end of file

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/equivalence.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+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> struct identity { using type = T; };
+template<typename T> using identity_t = T;
+
+// Type requirements
+template<typename T> requires requires { typename identity_t<T>; }
+struct r1;
+template<typename U> requires requires { typename identity_t<U>; } // expected-note{{previous template declaration is here}}
+struct r1;
+template<typename T> requires requires { typename identity_t<T*>; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r1;
+template<typename T> requires requires { typename ::identity_t<T>; }
+struct r1;
+
+template<typename Y> requires requires { typename identity<Y>::type; }
+struct r2;
+template<typename U> requires requires { typename identity<U>::type; }
+struct r2;
+template<typename T> requires requires { typename ::identity<T>::type; } // expected-note 2{{previous template declaration is here}}
+struct r2;
+template<typename T> requires requires { typename identity<T>::typr; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r2;
+namespace ns {
+  template<typename T> struct identity { using type = T; };
+}
+template<typename T> requires requires { typename ns::identity<T>::type; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r2;
+
+template<typename T> requires requires { typename T::template identity<T>::type; }
+struct r3;
+template<typename U> requires requires { typename U::template identity<U>::type; } // expected-note{{previous template declaration is here}}
+struct r3;
+template<typename T> requires requires { typename T::template identitr<T>::type; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r3;
+
+template<typename T> requires requires { typename T::template temp<>; }
+struct r4;
+template<typename U> requires requires { typename U::template temp<>; }
+struct r4;
+template<typename T> requires requires { typename T::template temp; }
+struct r4;
+
+// Expr requirements
+template<typename T> requires requires { 0; } // expected-note{{previous template declaration is here}}
+struct r5;
+template<typename T> requires requires { 1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r5;
+
+template<typename T>
+concept C1 = true;
+
+template<typename T> requires requires { sizeof(T); }
+struct r6;
+template<typename U> requires requires { sizeof(U); } // expected-note{{previous template declaration is here}}
+struct r6;
+template<typename U> requires requires { sizeof(U) - 1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) }; } // expected-note 3{{previous template declaration is here}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) } -> decltype(sizeof(int)); } // expected-error{{associated constraints differ in template redeclaration}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) } noexcept; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r6;
+
+template<typename T> requires requires { { sizeof(T) } -> int; }
+struct r7;
+template<typename U> requires requires { { sizeof(U) } -> int; } // expected-note 3{{previous template declaration is here}}
+struct r7;
+template<typename T> requires requires { { sizeof(T) } -> const int; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r7;
+template<typename T> requires requires { { sizeof(T) } noexcept -> int; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r7;
+template<typename T> requires requires { { sizeof(T) } -> T; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r7;
+
+template<typename T> requires requires { { sizeof(T) } -> C1; }
+struct r8;
+template<typename U> requires requires { { sizeof(U) } -> C1; }
+struct r8;
+template<typename T> requires requires { { sizeof(T) } -> C1<>; } // expected-note 2{{previous template declaration is here}}
+struct r8;
+template<typename U> requires requires { { sizeof(U) }; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r8;
+template<typename T> requires requires { { sizeof(T) } -> const C1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r8;
+
+template<typename T> requires requires { { sizeof(T) } -> const volatile C1; }
+struct r9;
+template<typename U> requires requires { { sizeof(U) } -> const volatile C1; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> C1 const volatile; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> C1 volatile const; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> const C1 volatile; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> volatile C1 const; }
+struct r9;
+
+template<typename T> requires requires { { sizeof(T) } -> C1[sizeof(T)]; }
+struct r10;
+template<typename U> requires requires { { sizeof(U) } -> C1[sizeof(U)]; } // expected-note 2{{previous template declaration is here}}
+struct r10;
+template<typename T> requires requires { { sizeof(T) } -> C1[sizeof(T) - 1]; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r10;
+template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r10;
+
+template<typename T> requires requires { { sizeof(T) } -> C1<T>; }
+struct r11;
+template<typename U> requires requires { { sizeof(U) } -> C1<U>; } // expected-note{{previous template declaration is here}}
+struct r11;
+template<typename T> requires requires { { sizeof(T) } -> C1<T*>; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r11;
+
+// Nested requirements
+template<typename T> requires requires { requires sizeof(T) == 0; }
+struct r12;
+template<typename U> requires requires { requires sizeof(U) == 0; } // expected-note{{previous template declaration is here}}
+struct r12;
+template<typename T> requires requires { requires sizeof(T) == 1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r12;
+
+// Parameter list
+template<typename T> requires requires { requires true; }
+struct r13;
+template<typename T> requires requires() { requires true; } // expected-note{{previous template declaration is here}}
+struct r13;
+template<typename T> requires requires(T i) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r13;
+
+template<typename T> requires requires(T i, T *j) { requires true; } // expected-note 2{{previous template declaration is here}}
+struct r14;
+template<typename T> requires requires(T i) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r14;
+template<typename T> requires requires(T i, T *j, T &k) { requires true; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r14;
+
+// Parameter names
+template<typename T> requires requires(int i) { requires sizeof(i) == 1; }
+struct r15;
+template<typename T> requires requires(int j) { requires sizeof(j) == 1; } // expected-note 2{{previous template declaration is here}}
+struct r15;
+template<typename T> requires requires(int k) { requires sizeof(k) == 2; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r15;
+template<typename T> requires requires(const int k) { requires sizeof(k) == 1; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r15;
+
+// Order of requirements
+template<typename T> requires requires { requires true; 0; }
+struct r16;
+template<typename T> requires requires { requires true; 0; } // expected-note{{previous template declaration is here}}
+struct r16;
+template<typename T> requires requires { 0; requires true; } // expected-error{{associated constraints differ in template redeclaration}}
+struct r16;
 No newline at end of file

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/nested-requirement.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+static_assert(requires { requires true; });
+
+template<typename T> requires requires { requires false; } // expected-note{{because 'false' evaluated to false}}
+struct r1 {};
+
+using r1i = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
+
+template<typename T> requires requires { requires sizeof(T) == 0; } // expected-note{{because 'sizeof(int) == 0' (4 == 0) evaluated to false}}
+struct r2 {};
+
+using r2i = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
+
+template<typename T> requires requires (T t) { requires sizeof(t) == 0; } // expected-note{{because 'sizeof (t) == 0' (4 == 0) evaluated to false}}
+struct r3 {};
+
+using r3i = r3<int>; // expected-error{{constraints not satisfied for class template 'r3' [with T = int]}}
+
+template<typename T>
+struct X {
+    template<typename U> requires requires (U u) { requires sizeof(u) == sizeof(T); } // expected-note{{because 'sizeof (u) == sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}}
+    struct r4 {};
+};
+
+using r4i = X<void>::r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with U = int]}}
+
+// C++ [expr.prim.req.nested] Examples
+namespace std_example {
+  template<typename U> concept C1 = sizeof(U) == 1; // expected-note{{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
+  template<typename T> concept D =
+    requires (T t) {
+      requires C1<decltype (+t)>; // expected-note{{because 'decltype(+t)' (aka 'int') does not satisfy 'C1'}}
+  };
+
+  struct T1 { char operator+() { return 'a'; } };
+  static_assert(D<T1>);
+  template<D T> struct D_check {}; // expected-note{{because 'short' does not satisfy 'D'}}
+  using dc1 = D_check<short>; // expected-error{{constraints not satisfied for class template 'D_check' [with T = short]}}
+
+  template<typename T>
+  concept C2 = requires (T a) { // expected-note{{'a' declared here}}
+      requires sizeof(a) == 4; // OK
+      requires a == 0; // expected-error{{constraint variable 'a' cannot be used in an evaluated context}}
+    };
+}
 No newline at end of file

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

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+// Examples from standard
+
+template<typename T>
+concept R = requires (T i) {
+  typename T::type;
+  {*i} -> const typename T::type&;
+};
+
+template<typename T> requires R<T> struct S {};
+
+struct T {
+  using type = int;
+  type i;
+  const type &operator*() { return i; }
+};
+
+using si = S<T>;
+
+template<typename T>
+requires requires (T x) { x + x; } // expected-note{{because 'x + x' would be invalid: invalid operands to binary expression ('T' and 'T')}}
+T add(T a, T b) { return a + b; } // expected-note{{candidate template ignored: constraints not satisfied [with T = T]}}
+
+int x = add(1, 2);
+int y = add(T{}, T{}); // expected-error{{no matching function for call to 'add'}}
+
+template<typename T>
+concept C = requires (T x) { x + x; }; // expected-note{{because 'x + x' would be invalid: invalid operands to binary expression ('T' and 'T')}}
+template<typename T> requires C<T> // expected-note{{because 'T' does not satisfy 'C'}}
+T add2(T a, T b) { return a + b; } // expected-note{{candidate template ignored: constraints not satisfied [with T = T]}}
+
+int z = add2(1, 2);
+int w = add2(T{}, T{}); // expected-error{{no matching function for call to 'add2'}}
 No newline at end of file

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/requires-expr.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+using A = int;
+
+template<typename T, typename U>
+constexpr bool is_same_v = false;
+
+template<typename T>
+constexpr bool is_same_v<T, T> = true;
+
+static_assert(requires { requires true; 0; typename A; { 0 } -> int; });
+static_assert(is_same_v<bool, decltype(requires { requires false; })>);
+
+// Check that requires expr is an unevaluated context.
+struct Y {
+  int i;
+  static constexpr bool r = requires { i; };
+};
+
+template<typename T> requires requires (T t) {
+  requires false; // expected-note{{because 'false' evaluated to false}}
+  requires false; // expected-note{{and 'false' evaluated to false}}
+  requires requires {
+    requires false; // expected-note{{and 'false' evaluated to false}}
+  };
+}
+struct r1 { };
+
+using r1i = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
+
+template<typename T> requires requires (T t) {
+  requires requires {
+    requires false; // expected-note{{because 'false' evaluated to false}}
+  };
+}
+struct r2 { };
+
+using r2i = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
+
+template<typename T> requires requires (T t) {
+  requires requires {
+    requires true;
+  };
+  requires true;
+  requires requires {
+    requires false; // expected-note{{because 'false' evaluated to false}}
+  };
+}
+struct r3 { };
+
+using r3i = r3<int>; // expected-error{{constraints not satisfied for class template 'r3' [with T = int]}}

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/simple-requirement.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+static_assert(requires { 0; });
+static_assert(requires { "aaaa"; });
+static_assert(requires { (0).da; }); // expected-error{{member reference base type 'int' is not a structure or union}}
+
+struct A {};
+struct B {
+    B operator+(const B &other) const { return other; }
+};
+struct C {
+    C operator+(C &other) const { return other; }
+};
+
+template<typename T> requires requires (T a, const T& b) { a + b; } // expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('A' and 'const A')}} expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('C' and 'const C')}}
+struct r1 {};
+
+using r1i1 = r1<int>;
+using r1i2 = r1<A>; // expected-error{{constraints not satisfied for class template 'r1' [with T = A]}}
+using r1i3 = r1<B>;
+using r1i4 = r1<C>; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}}
+
+struct D { void foo() {} };
+
+template<typename T> requires requires (T a) { a.foo(); } // expected-note{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}} expected-note{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}} expected-note{{because 'a.foo()' would be invalid: member function 'foo' not viable: 'this' argument has type 'const D', but function is not marked const}}
+struct r2 {};
+
+using r2i1 = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
+using r2i2 = r2<A>; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}}
+using r2i3 = r2<D>;
+using r2i4 = r2<const D>; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}}
+
+template<typename T> requires requires { sizeof(T); } // expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}}
+struct r3 {};
+
+using r3i1 = r3<int>;
+using r3i2 = r3<A>;
+using r3i3 = r3<A &>;
+using r3i4 = r3<void>; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}}
+using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}}
+
+template<typename T> requires requires (T t) { 0; "a"; (void)'a'; }
+struct r4 {};
+
+using r4i1 = r4<int>;
+using r4i2 = r4<int[10]>;
+using r4i3 = r4<int(int)>;
+
+// C++ [expr.prim.req.simple] Example
+namespace std_example {
+  template<typename T> concept C =
+    requires (T a, T b) { // expected-note{{because substituted constraint expression is ill-formed: argument may not have 'void' type}}
+      a + b; // expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('int *' and 'int *')}}
+    };
+
+  static_assert(C<int>);
+  template<C T> struct C_check {}; // expected-note{{because 'void' does not satisfy 'C'}} expected-note{{because 'int *' does not satisfy 'C'}}
+  using c1c1 = C_check<void>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = void]}}
+  using c1c2 = C_check<int *>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = int *]}}
+}
 No newline at end of file

test/CXX/concepts-ts/expr/expr.prim/expr.prim.req/type-requirement.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+using A = int;
+
+template<typename T> using identity_t = T; // expected-note 2{{template is declared here}}}
+
+template<typename T> struct identity { using type = T; };
+
+struct C {};
+
+struct D { static int type; };
+
+// Basic unqualified and global-qualified lookups
+
+static_assert(requires { typename A; typename ::A; });
+static_assert(requires { typename identity_t<A>; typename ::identity_t<A>; });
+static_assert(!requires { typename identity_t<A, A>; }); // expected-error{{too many template arguments for alias template 'identity_t'}}
+static_assert(!requires { typename ::identity_t<A, A>; }); // expected-error{{too many template arguments for alias template 'identity_t'}}
+static_assert(requires { typename identity<A>; });
+static_assert(!requires { typename identity; }); // expected-error{{'identity' does not name a type}}
+static_assert(!requires { typename ::identity; }); // expected-error{{'::identity' does not name a type}}
+static_assert(!requires { typename identity_t; }); // expected-error{{'identity_t' does not name a type}}
+static_assert(!requires { typename ::identity_t; }); // expected-error{{'::identity_t' does not name a type}}
+
+namespace ns {
+  using B = int;
+  int C = 0;
+  static_assert(requires { typename A; typename B; typename ::A; });
+  static_assert(!requires { typename ns::A; }); // expected-error{{'ns::A' does not name a type}}
+  static_assert(!requires { typename ::B; }); // expected-error{{'::B' does not name a type}}
+  static_assert(!requires { typename C; }); // expected-error{{'C' does not name a type}}
+}
+
+// member type lookups
+
+static_assert(requires { typename identity<int>::type; typename ::identity<int>::type; });
+static_assert(!requires { typename identity<int>::typr; }); // expected-error{{'identity<int>::typr' does not name a type}}
+static_assert(!requires { typename ::identity<int>::typr; }); // expected-error{{'::identity<int>::typr' does not name a type}}
+
+//
+
+template<typename T> requires requires { typename T::type; } // expected-note{{because 'T::type' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} expected-note{{because 'T::type' would be invalid: no type named 'type' in 'C'}} expected-note{{because 'T::type' would be invalid: typename specifier refers to non-type member 'type' in 'D'}}
+struct r1 {};
+
+using r1i1 = r1<identity<int>>;
+using r1i2 = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
+using r1i3 = r1<C>; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}}
+using r1i4 = r1<D>; // expected-error{{constraints not satisfied for class template 'r1' [with T = D]}}
+
+// mismatching template arguments
+
+template<typename... Ts> requires requires { typename identity<Ts...>; } // expected-note{{because 'identity<Ts...>' would be invalid: too many template arguments for class template 'identity'}}
+struct r2 {};
+
+using r2i1 = r2<int>;
+using r2i2 = r2<void>;
+using r2i3 = r2<int, int>; // expected-error{{constraints not satisfied for class template 'r2' [with Ts = <int, int>]}}
+
+namespace ns2 {
+  template<typename T, typename U> struct identity {};
+
+  template<typename... Ts> requires requires { typename identity<Ts...>; } // expected-note 2{{because 'identity<Ts...>' would be invalid: too few template arguments for class template 'identity'}}
+  struct r4 {};
+
+  using r4i1 = r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = <int>]}}
+}
+
+using r4i2 = ns2::r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = <int>]}}
+
+using E = int;
+template<typename T> requires requires { typename E<T>; } // expected-error{{template arguments provided for non-template 'E'}}
+struct r5v1 {};
+template<typename T> requires requires { typename ::E<T>; } // expected-error{{template arguments provided for non-template 'E'}}
+struct r5v2 {};
+
+template<typename T> requires sizeof(T) == 1
+struct chars_only {};
+
+template<typename T> requires requires { typename chars_only<T>; } // expected-note{{because 'chars_only<T>' would be invalid: constraints not satisfied for class template 'chars_only' [with T = int]}}
+struct r6 {};
+
+using r6i = r6<int>; // expected-error{{constraints not satisfied for class template 'r6' [with T = int]}}
+
+template<typename T> int F = 0;
+
+static_assert(!requires { typename F<int>; }); // expected-error{{'F' refers to a variable template and not a type template}}
+static_assert(!requires { typename ::F<int>; }); // expected-error{{'::F' refers to a variable template and not a type template}}
+
+struct G { template<typename T> static T temp; };
+
+template<typename T> requires requires { typename T::template temp<int>; } // expected-note{{because 'T::temp<int>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} expected-note{{because 'T::temp<int>' would be invalid: 'temp' following the 'template' keyword does not refer to a template}} expected-note{{because 'T::temp<int>' would be invalid: template name refers to non-type template 'G::temp'}}
+struct r7 {};
+
+using r7i1 = r7<int>; // expected-error{{constraints not satisfied for class template 'r7' [with T = int]}}
+using r7i2 = r7<D>; // expected-error{{constraints not satisfied for class template 'r7' [with T = D]}}
+using r7i3 = r7<G>; // expected-error{{constraints not satisfied for class template 'r7' [with T = G]}}
+
+template<typename T> struct H;
+
+template<typename T> requires requires { typename H<T>; }
+struct r8 {};
+
+using r8i = r8<int>;
+
+template<typename T> struct I { struct incomplete; }; // expected-note{{member is declared here}}
+
+static_assert(!requires { I<int>::incomplete::inner; }); // expected-error{{implicit instantiation of undefined member 'I<int>::incomplete'}}
+
+template<typename T> requires requires { typename I<T>::incomplete::inner; } // expected-note{{because 'I<T>::incomplete::inner' would be invalid: implicit instantiation of undefined member 'I<int>::incomplete'}}
+struct r9 {};
+
+using r9i = r9<int>; // expected-error{{constraints not satisfied for class template 'r9' [with T = int]}}
+
+namespace ns3 {
+  struct X { }; // expected-note 2{{candidate found by name lookup is 'ns3::X'}}
+}
+
+struct X { using inner = int; }; // expected-note 2{{candidate found by name lookup is 'X'}}
+
+using namespace ns3;
+static_assert(requires { typename X; }); // expected-error{{reference to 'X' is ambiguous}}
+static_assert(requires { typename X::inner; }); // expected-error{{reference to 'X' is ambiguous}}
+
+// naming a type template specialization in a type requirement does not require
+// it to be complete and should not care about partial specializations.
+
+template<typename T>
+struct Z;
+
+template<typename T> requires sizeof(T) >= 1
+struct Z<T> {}; // expected-note{{partial specialization matches [with T = int]}}
+
+template<typename T> requires sizeof(T) <= 4
+struct Z<T> {}; // expected-note{{partial specialization matches [with T = int]}}
+
+Z<int> x; // expected-error{{ambiguous partial specializations of 'Z<int>'}}
+
+static_assert(requires { typename Z<int>; });
+
+// C++ [expr.prim.req.type] Example
+namespace std_example {
+  template<typename T, typename T::type = 0> struct S; // expected-note{{and 'S<T>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} expected-note{{because 'S<T>' would be invalid: no type named 'type' in 'std_example::has_inner}} expected-note{{and 'S<T>' would be invalid: type 'void' cannot be used prior to '::' because it has no members}}
+  template<typename T> using Ref = T&; // expected-note{{and 'Ref<T>' would be invalid: cannot form a reference to 'void'}}
+  template<typename T> concept C =
+    requires {
+      typename T::inner; // expected-note{{because 'T::inner' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} expected-note{{because 'T::inner' would be invalid: no type named 'inner' in 'std_example::has_type'}} expected-note{{because 'T::inner' would be invalid: type 'void' cannot be used prior to '::' because it has no members}}
+      typename S<T>;
+      typename Ref<T>;
+    };
+
+  struct has_inner { using inner = int;};
+  struct has_type { using type = int; };
+  struct has_inner_and_type { using inner = int; using type = int; };
+
+  static_assert(C<has_inner_and_type>);
+  template<C T> struct C_check {}; // expected-note{{because 'int' does not satisfy 'C'}} expected-note{{because 'std_example::has_type' does not satisfy 'C'}} expected-note{{because 'std_example::has_inner' does not satisfy 'C'}} expected-note{{because 'void' does not satisfy 'C'}}
+  using c1 = C_check<int>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = int]}}
+  using c2 = C_check<has_type>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = std_example::has_type]}}
+  using c3 = C_check<has_inner>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = std_example::has_inner]}}
+  using c4 = C_check<void>; // expected-error{{constraints not satisfied for class template 'C_check' [with T = void]}}
+}
 No newline at end of file

test/Parser/cxx-concepts-requires-expr.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+bool r1 = requires () {}; // expected-error{{a requires expression must contain at least one requirement}}
+
+bool r2 = requires { requires true; };
+
+bool r3 = requires (int a, ...) { requires true; }; // expected-error{{varargs not allowed in requires expression}}
+
+template<typename... T>
+bool r4 = requires (T... ts) { requires true; };
+
+bool r5 = requires (bool c, int d) { c; d; };
+
+bool r6 = requires (bool c, int d) { c; d; } && decltype(d){}; // expected-error{{use of undeclared identifier 'd'}}
+
+bool r7 = requires (bool c) { c; (requires (int d) { c; d; }); d; } && decltype(c){} && decltype(d){}; // expected-error 2{{use of undeclared identifier 'd'}} expected-error{{use of undeclared identifier 'c'}}
+
+bool r8 = requires (bool, int) { requires true; };
+
+bool r9 = requires (bool a, int a) { requires true; }; // expected-error{{redefinition of parameter 'a'}} expected-note{{previous declaration is here}}
+
+bool r10 = requires (struct new_struct { int x; } s) { requires true; }; // expected-error{{'new_struct' cannot be defined in a parameter type}}
+
+bool r11 = requires (int x(1)) { requires true; }; // expected-error{{expected parameter declarator}} expected-error{{expected ')'}} expected-note{{to match this '('}}
+
+bool r12 = requires (int x = 10) { requires true; }; // expected-error{{default arguments not allowed for parameters of a requires expression}}
+
+bool r13 = requires (int f(int)) { requires true; };
+
+bool r14 = requires (int (*f)(int)) { requires true; };
+
+bool r15 = requires (10) { requires true; }; // expected-error{{expected parameter declarator}}
+
+bool r16 = requires (auto x) { requires true; }; // expected-error{{'auto' not allowed in requires expression parameter}}
+
+bool r17 = requires (auto [x, y]) { requires true; }; // expected-error{{'auto' not allowed in requires expression parameter}} expected-error{{use of undeclared identifier 'x'}}
+
+using a = int;
+
+bool r18 = requires { typename a; };
+
+bool r19 = requires { typename ::a; };
+
+template<typename T> struct identity { using type = T; };
+
+template<typename T> using identity_t = T;
+
+bool r20 = requires {
+    typename identity<int>::type;
+    typename identity<int>;
+    typename ::identity_t<int>;
+};
+
+struct s { bool operator==(const s&); ~s(); };
+
+bool r21 = requires { typename s::operator==; }; // expected-error {{expected identifier or template-id in type requirement}}
+
+bool r22 = requires { typename s::~s; }; // expected-error {{expected identifier or template-id in type requirement}}
+
+template<typename T>
+bool r23 = requires { typename identity<T>::temp<T>; }; // expected-error{{use 'template' keyword to treat 'temp' as a dependent template name}}
+
+template<typename T>
+bool r24 = requires {
+    typename identity<T>::template temp<T>;
+    typename identity<T>::template temp; // FIXME: This parses fine, should it?
+};
+
+bool r25 = requires { ; }; // expected-error{{expected expression}}
+
+bool r26 = requires { {}; }; // expected-error{{expected expression}}
+
+bool r27 = requires { { 0 } noexcept; };
+
+bool r28 = requires { { 0 } noexcept noexcept; }; // expected-error{{expected '->' before expression type requirement}}
+
+bool r29 = requires { { 0 } noexcept int; }; // expected-error{{expected '->' before expression type requirement}}
+
+template<typename T>
+concept C1 = true;
+
+bool r30 = requires { { 0 } noexcept -> const volatile C1; };
+
+bool r31 = requires { { 0 } noexcept -> const C1 volatile; };
+
+bool r32 = requires { { 0 } noexcept -> C1 const volatile; };
+
+bool r33 = requires { { 0 } noexcept -> const volatile C1 const volatile; }; // expected-warning {{duplicate 'const' declaration specifier}} expected-warning {{duplicate 'volatile' declaration specifier}}
+
+bool r34 = requires { { 0 } noexcept -> const volatile C1[1]; };
+
+bool r35 = requires { { 0 } noexcept -> const C1 volatile[1]; };
+
+bool r36 = requires { { 0 } noexcept -> C1 const volatile[1]; };
+
+bool r37 = requires { { 0 } noexcept -> const volatile C1 const volatile[1]; }; // expected-warning {{duplicate 'const' declaration specifier}} expected-warning {{duplicate 'volatile' declaration specifier}}
+
+bool r38 = requires { { 0 } noexcept -> const C1 *(int); };
+
+template<typename T>
+T i1 = 0;
+
+bool r39 = requires { { 0 } noexcept -> const volatile i1; }; // expected-error{{unknown type name 'i1'}}
+
+bool r40 = requires { { 0 } noexcept -> const int; };
+
+bool r41 = requires { { 0 } noexcept -> const volatile decltype(i1<int>); };
+
+template<typename T, typename U>
+concept C2 = true;
+
+bool r42 = requires { { 0 } noexcept -> const volatile C2; }; // expected-error{{concept 'C2' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}}
+
+bool r43 = requires { { 0 } noexcept -> const volatile C1<>; };
+
+bool r44 = requires { { 0 } noexcept -> const volatile C2<int>; };
+
+bool r45 = requires { requires false, 1; }; // expected-error{{expected ';' at end of requirement}}
+
+bool r46 = requires { 0 noexcept; }; // expected-error{{'noexcept' can only be used in a compound requirements (with '{' '}' around the expression)}}
+
+bool r47 = requires { 0 int; }; // expected-error{{unexpected int after expression. Did you intend to use a compound requirement? (with '{' '}' around the expression)}}
+
+bool r48 = requires { requires true }; // expected-error{{expected ';' at end of requirement}}
+
+bool r49 = requires (bool b) { requires sizeof(b) == 1; };
+
+void r50(bool b) requires requires { 1 } {} // expected-error{{expected ';' at end of requirement}}
 No newline at end of file

test/SemaTemplate/instantiate-requires-expr.cpp

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify -Wno-unused-value
+
+template<typename T, typename U>
+constexpr bool is_same_v = false;
+
+template<typename T>
+constexpr bool is_same_v<T, T> = true;
+
+// We use a hack in this file to make the compiler print out the requires
+// expression after it has been instantiated - we put false_v<requires {...}> as
+// the requires clause of a class template, then instantiate the template.
+// The requirement will not be satisfied, and the explaining diagnostic will
+// print out false_v<requires {...}> in its raw form (the false_v serves to
+// prevent the diagnostic from elaborating on why the requires expr wasn't
+// satisfied).
+
+template<bool v>
+constexpr bool false_v = false;
+
+template<typename... Ts>
+using void_t = void;
+
+// Check that requires parameters are instantiated correctly.
+
+template<typename T> requires
+false_v<requires (T t) { requires is_same_v<decltype(t), int>; }> // expected-note {{because 'false_v<requires (int t) { requires is_same_v<decltype(t), int>; }>' evaluated to false}} expected-note {{because 'false_v<requires (char t) { requires is_same_v<decltype(t), int>; }>' evaluated to false}}
+struct r1 {};
+
+using r1i1 = r1<int>; // expected-error {{constraints not satisfied for class template 'r1' [with T = int]}}
+using r1i2 = r1<char>; // expected-error {{constraints not satisfied for class template 'r1' [with T = char]}}
+
+// Check that parameter packs work.
+
+template<typename... Ts> requires
+false_v<requires (Ts... ts) {requires ((sizeof(ts) == 2) && ...);}> // expected-note{{because 'false_v<requires (short ts, unsigned short ts) { requires (sizeof (ts) == 2) && (sizeof (ts) == 2); }>'}} expected-note{{because 'false_v<requires (short ts) { requires (sizeof (ts) == 2); }>' evaluated to false}}
+struct r2 {};
+
+using r2i1 = r2<short, unsigned short>; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = <short, unsigned short>]}}
+using r2i2 = r2<short>; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = <short>]}}
+
+template<typename... Ts> requires
+false_v<(requires (Ts ts) {requires sizeof(ts) != 0;} && ...)> // expected-note{{because 'false_v<requires (short ts) { requires sizeof (ts) != 0; } && requires (unsigned short ts) { requires sizeof (ts) != 0; }>' evaluated to false}} expected-note{{because 'false_v<requires (short ts) { requires sizeof (ts) != 0; }>' evaluated to false}}
+struct r3 {};
+
+using r3i1 = r3<short, unsigned short>; // expected-error {{constraints not satisfied for class template 'r3' [with Ts = <short, unsigned short>]}}
+using r3i2 = r3<short>; // expected-error {{constraints not satisfied for class template 'r3' [with Ts = <short>]}}
+
+template<typename T>
+struct identity { using type = T; };
+
+namespace type_requirement {
+  struct A {};
+
+  // check that nested name specifier is instantiated correctly.
+  template<typename T> requires false_v<requires { typename T::type; }> // expected-note{{because 'false_v<requires { typename identity<int>::type; }>' evaluated to false}}
+  struct r1 {};
+
+  using r1i = r1<identity<int>>; // expected-error{{constraints not satisfied for class template 'r1' [with T = identity<int>]}}
+
+  // check that template argument list is instantiated correctly.
+  template<typename T>
+  struct contains_template {
+      template<typename U> requires is_same_v<contains_template<T>, U>
+      using temp = int;
+  };
+
+  template<typename T> requires
+  false_v<requires { typename T::template temp<T>; }> // expected-note{{because 'false_v<requires { typename contains_template<int>::temp<contains_template<int> >; }>' evaluated to false}} expected-note{{because 'false_v<requires { typename contains_template<short>::temp<contains_template<short> >; }>' evaluated to false}}
+  struct r2 {};
+
+  using r2i1 = r2<contains_template<int>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template<int>]}}
+  using r2i2 = r2<contains_template<short>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template<short>]}}
+
+  // substitution error occurs, then requires expr is instantiated again
+
+  template<typename T>
+  struct a {
+      template<typename U> requires (requires { typename T::a::a; }, false) // expected-note{{because 'requires { typename <<error-type>>; } , false' evaluated to false}}
+      struct r {};
+  };
+
+  using ari = a<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
+
+  // Parameter pack inside expr
+  template<typename... Ts> requires
+  false_v<(requires { typename Ts::type; } && ...)> // expected-note{{because 'false_v<requires { typename identity<short>::type; } && requires { typename identity<int>::type; } && requires { typename <<error-type>>; }>' evaluated to false}}
+  struct r5 {};
+
+  using r5i = r5<identity<short>, identity<int>, short>; // expected-error{{constraints not satisfied for class template 'r5' [with Ts = <identity<short>, identity<int>, short>]}}
+  template<typename... Ts> requires
+  false_v<(requires { typename void_t<Ts>; } && ...)> // expected-note{{because 'false_v<requires { typename void_t<int>; } && requires { typename void_t<short>; }>' evaluated to false}}
+  struct r6 {};
+
+  using r6i = r6<int, short>; // expected-error{{constraints not satisfied for class template 'r6' [with Ts = <int, short>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { typename Ts::template aaa<Ts>; } && ...)> // expected-note{{because 'false_v<requires { typename <<error-type>>; } && requires { typename <<error-type>>; }>' evaluated to false}}
+  struct r7 {};
+
+  using r7i = r7<int, A>; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = <int, type_requirement::A>]}}
+}
+
+namespace expr_requirement {
+  // check that compound/simple requirements are instantiated correctly.
+
+  template<typename T> requires false_v<requires { sizeof(T); { sizeof(T) }; }> // expected-note{{because 'false_v<requires { sizeof(int); { sizeof(int) }; }>' evaluated to false}} expected-note{{because 'false_v<requires { <<error-expression>>; { <<error-expression>> }; }>' evaluated to false}}
+  struct r1 {};
+
+  using r1i1 = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
+  using r1i2 = r1<void>; // expected-error{{constraints not satisfied for class template 'r1' [with T = void]}}
+
+  // substitution error occurs in expr, then expr is instantiated again.
+
+  template<typename T>
+  struct a {
+      template<typename U> requires (requires { sizeof(T::a); }, false) // expected-note{{because 'requires { <<error-expression>>; } , false' evaluated to false}}
+      struct r {};
+  };
+
+  using ari = a<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
+
+  // check that trailing-return-type requirement is instantiated correctly.
+
+  template<typename T> requires
+  false_v<requires { { sizeof(T) } -> typename T::type; }> // expected-note{{because 'false_v<requires { { sizeof(identity<int>) } -> typename identity<int>::type; }>' evaluated to false}}
+  struct r2 {};
+
+  using r2i = r2<identity<int>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = identity<int>]}}
+
+  // check that constrained-parameter is instantiated correctly.
+
+  template<typename T>
+  concept C1 = is_same_v<T, int>;
+
+  template<typename T> requires false_v<requires(T t) { { t } -> C1<T>; }> // expected-note{{because 'false_v<requires (int t) { { t } -> C1<int>; }>' evaluated to false}} expected-note{{because 'false_v<requires (double t) { { t } -> C1<double>; }>' evaluated to false}}
+  struct r3 {};
+
+  using r3i1 = r3<int>; // expected-error{{constraints not satisfied for class template 'r3' [with T = int]}}
+  using r3i2 = r3<double>; // expected-error{{constraints not satisfied for class template 'r3' [with T = double]}}
+
+  void foo(int, double) {}
+
+  template<typename T> requires
+  false_v<requires(T t) { { foo } -> C1(int, T); }> // expected-note{{because 'false_v<requires (double t) { { foo } -> C1 (int, double); }>' evaluated to false}} expected-note{{because 'false_v<requires (int t) { { foo } -> C1 (int, int); }>' evaluated to false}}
+  struct r4 {};
+
+  using r4i1 = r4<double>; // expected-error{{constraints not satisfied for class template 'r4' [with T = double]}}
+  using r4i2 = r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with T = int]}}
+
+  // substitution error occurs in return type requirement, then requires expr is
+  // instantiated again.
+
+  template<typename T>
+  struct b {
+      template<typename U> requires (requires { { 0 } -> typename T::a; }, false) // expected-note{{because 'requires { { 0 } -> <<error-type>>; } , false' evaluated to false}}
+      struct r {};
+  };
+
+  using bri = b<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
+
+  // Parameter pack inside expr
+  template<typename... Ts> requires
+  false_v<(requires { { sizeof(Ts) } noexcept -> int; } && ...)> // expected-note{{because 'false_v<requires { { sizeof(int) } noexcept -> int; } && requires { { sizeof(short) } noexcept -> int; }>' evaluated to false}}
+  struct r5 {};
+
+  using r5i = r5<int, short>; // expected-error{{constraints not satisfied for class template 'r5' [with Ts = <int, short>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { sizeof(Ts); } && ...)> // expected-note{{because 'false_v<requires { sizeof(int); } && requires { sizeof(short); }>' evaluated to false}}
+  struct r6 {};
+
+  using r6i = r6<int, short>; // expected-error{{constraints not satisfied for class template 'r6' [with Ts = <int, short>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { { 0 } noexcept -> Ts; } && ...)> // expected-note{{because 'false_v<requires { { 0 } noexcept -> int; } && requires { { 0 } noexcept -> unsigned int; } && requires { { 0 } noexcept -> long; }>' evaluated to false}}
+  struct r7 {};
+
+  using r7i = r7<int, unsigned int, long>; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = <int, unsigned int, long>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { { 0 } noexcept -> const C1(Ts); } && ...)> // expected-note{{because 'false_v<requires { { 0 } noexcept -> const C1 (int); } && requires { { 0 } noexcept -> const C1 (unsigned int); }>' evaluated to false}}
+  struct r8 {};
+
+  using r8i = r8<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r8' [with Ts = <int, unsigned int>]}}
+
+  template<typename T, typename U>
+  concept C2 = true;
+
+  template<typename... Ts> requires
+  false_v<(requires { { 0 } noexcept -> C2<Ts>[3]; } && ...)> // expected-note{{because 'false_v<requires { { 0 } noexcept -> C2<int> [3]; } && requires { { 0 } noexcept -> C2<unsigned int> [3]; }>' evaluated to false}}
+  struct r9 {};
+
+  using r9i = r9<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r9' [with Ts = <int, unsigned int>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { { sizeof(Ts) } noexcept -> C2<Ts>[sizeof(Ts)]; } && ...)> // expected-note{{because 'false_v<requires { { sizeof(int) } noexcept -> C2<int> [4]; } && requires { { sizeof(long) } noexcept -> C2<long> [8]; }>' evaluated to false}}
+  struct r10 {};
+
+  using r10i = r10<int, long>; // expected-error{{constraints not satisfied for class template 'r10' [with Ts = <int, long>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { { sizeof(Ts) } noexcept -> const volatile Ts; } && ...)> // expected-note{{because 'false_v<requires { { sizeof(int) } noexcept -> const volatile int; } && requires { { sizeof(unsigned int) } noexcept -> const volatile unsigned int; }>' evaluated to false}}
+  struct r11 {};
+
+  using r11i = r11<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r11' [with Ts = <int, unsigned int>]}}
+}
+
+namespace nested_requirement {
+  // check that constraint expression is instantiated correctly
+  template<typename T> requires false_v<requires { requires sizeof(T) == 2; }> // expected-note{{because 'false_v<requires { requires sizeof(int) == 2; }>' evaluated to false}}
+  struct r1 {};
+
+  using r1i = r1<int>; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}}
+
+  // substitution error occurs in expr, then expr is instantiated again.
+  template<typename T>
+  struct a {
+      template<typename U> requires
+      (requires { requires sizeof(T::a) == 0; }, false) // expected-note{{because 'requires { requires <<error-expression>>; } , false' evaluated to false}}
+      struct r {};
+  };
+
+  using ari = a<int>::r<short>; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}}
+
+  // Parameter pack inside expr
+  template<typename... Ts> requires
+  false_v<(requires { requires sizeof(Ts) == 0; } && ...)> // expected-note{{because 'false_v<requires { requires sizeof(int) == 0; } && requires { requires sizeof(short) == 0; }>' evaluated to false}}
+  struct r2 {};
+
+  using r2i = r2<int, short>; // expected-error{{constraints not satisfied for class template 'r2' [with Ts = <int, short>]}}
+}
+
+// Parameter pack inside multiple requirements
+template<typename... Ts> requires
+false_v<(requires { requires sizeof(Ts) == 0; sizeof(Ts); } && ...)> // expected-note{{because 'false_v<requires { requires sizeof(int) == 0; sizeof(int); } && requires { requires sizeof(short) == 0; sizeof(short); }>' evaluated to false}}
+struct r4 {};
+
+using r4i = r4<int, short>; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = <int, short>]}}
+
+template<typename... Ts> requires
+false_v<(requires(Ts t) { requires sizeof(t) == 0; t++; } && ...)> // expected-note{{because 'false_v<requires (int t) { requires sizeof (t) == 0; t++; } && requires (short t) { requires sizeof (t) == 0; t++; }>' evaluated to false}}
+struct r5 {};
+
+using r5i = r5<int, short>; // expected-error{{constraints not satisfied for class template 'r5' [with Ts = <int, short>]}}

tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::ArrayTypeTraitExprClass:
   case Stmt::AsTypeExprClass:
   case Stmt::AtomicExprClass:
   case Stmt::BinaryConditionalOperatorClass:
   case Stmt::TypeTraitExprClass:
   case Stmt::CoroutineBodyStmtClass:
   case Stmt::CoawaitExprClass:
   case Stmt::ConceptSpecializationExprClass:
+  case Stmt::RequiresExprClass:
   case Stmt::DependentCoawaitExprClass:
   case Stmt::CoreturnStmtClass:
   case Stmt::CoyieldExprClass:
   case Stmt::CXXBindTemporaryExprClass:
   case Stmt::CXXDefaultArgExprClass:
   case Stmt::CXXDefaultInitExprClass:
   case Stmt::CXXFoldExprClass:
   case Stmt::CXXStdInitializerListExprClass: