[Concepts] Type Constraints

[saar.raz]

Summary

Added support for type-constraints in template type parameters. Depends on D43357.

[saar.raz]

Fixed test.

[saar.raz]

Adjusted to changes in dependent patches.

[saar.raz]

Split TryParseConstrainedParameter and ParseConstrainedTemplateParameter in preparation for requries expressions.

[martong]

lib/AST/ASTImporter.cpp

3708 ↗

(On Diff #159378)

Please use the import function instead of VisitExpr. Calling VisitExpr would return immediately with an error, that's the default case of the StmtVisitor.
Also please check that there was no error during the import of the CE expression:

ExpectedExpr CEOrErr = import(D->getConstraintExpression());
if (!CEOrErr)
  return CEOrErr.takeError();
R->setConstraintExpression(*CEOrErr);

And could you please adjust the changes below too?

[balazske]

lib/AST/ASTImporter.cpp

3708 ↗

(On Diff #159378)

The code above works without the if (Expr *CE = D->getConstraintExpression()) too. The import returns nullptr for a nullptr (*CEOrErr will be nullptr and no error).

[saar.raz]

• Fixed bad ordering of associated constraints
• Fixed ignoring of ScopeSpecifier in constrained parameters
• Adjustments for template template parameter handling
• Fixed constrained template template parameter and argument handling

[rsmith]

This needs revision to reflect changes between the Concepts TS and C++20. In particular, only the name of a type-concept can be used to declare a template-parameter in the new rules:

template<typename> concept A = true;
template<template<typename> typename> B = true;
template<int> concept C = true;

template<A> struct XA {}; // ok
template<B> struct XB {}; // error, not a type-concept
template<C> struct XC {}; // error, not a type-concept

We don't appear to have any explicit representation of the type-concept as written, only of its immediately-declared constraint. One design goal of Clang is for the AST to directly represent the program as written (to the extent possible) to facilitate writing tools on top of Clang's AST. Please consider adding a representation of the TypeConstraint itself. (This could be as simple as a wrapper around the Expr* that you currently have, that provides access to the concept name and the template arguments, and additionally stores a flag to determine whether an explicit template argument list was specified, to distinguish TypeConcept from TypeConcept<>.)

lib/Parse/ParseTemplate.cpp

590–619 ↗

(On Diff #195801)

This is out of date compared to the current C++20 wording.

677 ↗

(On Diff #195801)

This should not require tentative parsing. We should be able to annotate the nested-name-specifier (if any) then determine whether we have a type-name or a type-constraint with a single token of lookahead.

1039–1045 ↗

(On Diff #195801)

This is incorrect; this rule was removed when concepts were merged into C++20.

1153–1176 ↗

(On Diff #195801)

All the work to build expressions and establish the semantic effects of declarations should be done by Sema, not by the Parser. The Parser should just figure out how the program matches the grammar, and report to Sema what it found.

[saar.raz]

• removed old handling of constrained-parameters for type-constraints
• use template-id annotations during parsing to avoid tentative parses and set the ground for placeholder type-constraints
• add source information to the new TypeConstraint class, which shares a base class (ConceptReference) with ConceptSpecializationExpr
• change TemplateTypeParmDecl to not return true for wasDeclaredWithTypename if a type-constraint was present (and update places that assumed only 'class' or 'typename' were possible)

[saar.raz]

• Fixed bad wereArgumentsSpecified() implementation

[saar.raz]

Adjust to changes in previous patches

[saar.raz]

Fix incorrect patch upload

[saar.raz]

Fix incorrect comparison of type-constraints in template template argument matching

[saar.raz]

Rebase onto trunk.

[rsmith]

include/clang/AST/ASTNodeTraverser.h

518 ↗

(On Diff #209698)

For consistency with DeclRefExpr, I think this function should be called hasExplicitTemplateArgs.

include/clang/AST/RecursiveASTVisitor.h

1775

We should visit the nested name specifier and concept name too. Perhaps it'd make sense to add a TraverseConceptReference extension point and call it from here and from visitation of a ConceptSpecializationExpr?

include/clang/Basic/DiagnosticSemaKinds.td

2532

"must not be" -> "is"

2536

"must be" -> "is not"

lib/AST/ASTContext.cpp

703–707 ↗

(On Diff #209698)

Canonicalization should presumably also remove / canonicalize the "as-written" parts here: no NestedNameSpecifierLoc, no template keyword location, the found decl should just be the named concept itself, and the explicit template arguments should be canonicalized. (We don't want the locations and "as-written" parts from the first instance of a particular template template parameter that we happen to encounter to be reachable through later declarations of identical template template parameters.)

709–716 ↗

(On Diff #209698)

Similarly, we presumably shouldn't be preserving locations here through canonicalization.

lib/AST/DeclPrinter.cpp

1048–1049 ↗

(On Diff #209698)

Nit: I think this would read more naturally if the type constraint case were first.

lib/AST/TextNodeDumper.cpp

1680–1682 ↗

(On Diff #209698)

As above, I think this would be clearer if the "type constraint" and "typename" cases were reversed.

1689 ↗

(On Diff #209698)

It'd be useful to dump either the explicit arguments or the immediately-declared constraint here.

lib/Parse/ParseExprCXX.cpp

163–164

We don't need both of these :)

486–489

Is this necessary for this change in particular? (I'd expect isTemplateName to be able to cope with this corner case.)

lib/Parse/ParseTemplate.cpp

552 ↗

(On Diff #209698)

Have we necessarily annotated a template-id at this point, if necessary? Usually functions that want to look at template-id annotations perform that annotation themselves rather than imposing a side-condition on their caller to do it before calling them.

619–644 ↗

(On Diff #209698)

As mentioned above, I'd expect this all to be done by isStartOfTemplateTypeParameter itself.

679–681 ↗

(On Diff #209698)

I'd drop the second sentence of this comment. We don't need to talk about how the language works in the parser, just how to parse it.

683–686 ↗

(On Diff #209698)

This is out-of-date compared to the C++20 wording.

801–811 ↗

(On Diff #209698)

Does this need to be done as two separate steps? (I wonder if combining them might allow us to remove the complexity of having a "has an invalid type constraint" state from TemplateTypeParmDecl.)

1286 ↗

(On Diff #209698)

Interesting. So we're using a tok::annot_template_id annotation for this even in the case where we have no template arguments, so it's not actually a template-id? That's a bit weird, but I'm not necessarily opposed if it keeps things simpler. Please at least mention that in the comment on ANNOTATION(template_id) in Basic/TokenKinds.def, and also in the doc comment for class TemplateIdAnnotation.

lib/Sema/SemaCXXScopeSpec.cpp

620 ↗

(On Diff #209698)

Nit: && on the previous line, please.

lib/Sema/SemaConcept.cpp

844–847

Please go ahead and commit this renaming (as a separate change).

lib/Sema/SemaTemplate.cpp

1059 ↗

(On Diff #209698)

Fixit hints on an error or warning should be valid C++ code that fixes the problem, and you should recover as if the fix were applied. See http://clang.llvm.org/docs/InternalsManual.html#fix-it-hints for the rules and rationale.

We don't have a way of annotating text on a diagnostic that isn't a fixit hint (although we probably should); for now, let's just omit the hint. (Maybe add a FIXME though?)

1087 ↗

(On Diff #209698)

This (and the later references to it) have the wrong section and paragraph listed: this is [temp.param]p4 not [temp]p6.

1089 ↗

(On Diff #209698)

Please replace these characters (ellipsis and prime) with ASCII; bad things may happen to these characters when this file is viewed from an editor that defaults to something other than UTF-8 (which is quite likely on Windows).

1123 ↗

(On Diff #209698)

Similarly here.

1967–1983 ↗

(On Diff #209698)

This will substitute into each of the template arguments twice. It would be better to rebuild the immediately-declared constraint from scratch (and that might even be necessary for correctness in some cases: if a template argument contains a lambda-expression, we should introduce only one closure type, not two -- and will in any case avoid duplicate warnings).

7047 ↗

(On Diff #209698)

We shouldn't gate this behind ConceptsTS. Let's just start turning RelaxedTemplateTemplateArgs on unconditionally. (This breaks at least one testcase, but it's not clear that it's a real world problem.)

As a separate change, though :)

lib/Sema/SemaTemplateInstantiateDecl.cpp

2326–2327

As above, this should be recreated from scratch, not substituted.

[saar.raz]

Rebase onto trunk.
Address CR comments by rsmith.

[saar.raz]

Addressed all but one comment in recent commit.

[saar.raz]

Remove accidental change to CMakeLists.txt

[rsmith]

clang/include/clang/AST/DeclTemplate.h

1297–1300 ↗

(On Diff #237228)

It'd be more efficient to ask if the immediately-declared constraint is a CXXFoldExpr, but it's a bit ugly to depend on that here. What do you think?

clang/lib/Parse/ParseTemplate.cpp

553 ↗

(On Diff #237228)

I'm a bit confused by what's going on with this SuppressDiagnostic flag. This isn't a tentative parse; if we don't produce diagnostics for an invalid scope specifier here, I don't see anything that guarantees that any later code will produce any diagnostics either, which would be a problem. I would expect to be able to parse and produce diagnostics normally here, without this SuppressDiagnostic flag.

635 ↗

(On Diff #237228)

If isStartOfTemplateTypeParameter fails due to an invalid scope specifier, can we just return nullptr immediately, rather than making a likely-ill-fated attempt to parse a template or non-type parameter? It seems unlikely that we can reasonably recover in that case.

676–677 ↗

(On Diff #237228)

This is a bit surprising: the other bool TryAnnotate* functions follow the normal convention of returning true if they've encountered and diagnosed a parse error (and the caller is expected to check Tok to see whether it was annotated). Please consider making this consistent with the other similar functions.

715–716 ↗

(On Diff #237228)

I would expect it to fail if the template argument list is malformed, and in that case we should fail too.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

2484 ↗

(On Diff #237228)

Nit: please add braces to this outer if.

[saar.raz]

Address some CR comments.

[saar.raz]

This comment was removed by saar.raz.

[saar.raz]

Remove SuppressDiagnostics, conform TryAnnotateTypeConstraint, readd concepts to relaxed template argument check, fix recovery from bad scope in ParseTemplateParameter

[rsmith]

Some cleanups (mainly parameters that are no longer necessary), then this is good to go. Thanks!

clang/include/clang/Basic/LangOptions.def

146 ↗

(On Diff #237478)

This change has no effect because the default value is unconditionally overwritten in CompilerInvocation.cpp. Revert for now; we can flip this flag as a separate change.

clang/lib/AST/DeclTemplate.cpp

110–114 ↗

(On Diff #237478)

Do we need something like this for expanded template template parameter packs?

clang/lib/Parse/ParseExprCXX.cpp

2713 ↗

(On Diff #237478)

This SuppressDiag parameter is never set by any caller; please remove it.

clang/lib/Parse/ParseTemplate.cpp

684 ↗

(On Diff #237478)

ScopeError is always false here; you can remove the ErrorInTypeSpec parameter and the comment here.

707 ↗

(On Diff #237478)

The Tok.is check here is redundant; it's a subset of the following Tok.isNot check.

clang/lib/Sema/SemaTemplate.cpp

136 ↗

(On Diff #237478)

This new parameter appears to be unused now.

7088 ↗

(On Diff #237478)

This is not appropriate; -fconcepts-ts (or hopefully soon -std=c++2a) should not override the value of this LangOpt.

Please revert this change and manually turn on -frelaxed-template-template-args as necessary in the corresponding test cases.

clang/lib/Sema/SemaTemplateDeduction.cpp

645–659 ↗

(On Diff #237478)

Looks like we repeat this (at least) three times. (And one of the instances is missing the template template parameter case.) Please consider moving this to somewhere more central (DeclTemplate.h?) -- as a separate patch, though.

[ychen]

I saw a null pointer dereference for the p3-2a.cpp file added here. It is not always reproducible for me, I was able to reproduce it once offline. Any idea?

Crash stack is here:
https://results.llvm-merge-guard.org/amd64_debian_testing_clang8-1220/console-log.txt

From D67847, you could see that the first time merge bot is ran, p3-2a.cpp failed. The second time, without me doing anything except updating some unrelated tests, p3-2a.cpp passes.

include/clang/AST/DeclCXX.h

bool isCopyDeductionCandidate() const {
     return FunctionDeclBits.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; }
+};
+
 /// 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

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 getBeginLoc() const LLVM_READONLY { return RequiresKWLoc; }
+  SourceLocation getEndLoc() 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

 DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
 DEF_TRAVERSE_DECL(TemplateTypeParmDecl, {
   // D is the "T" in something like "template<typename T> class vector;"
   if (D->getTypeForDecl())
     TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
   if (const auto *TC = D->getTypeConstraint())
     if (TC->wereArgumentsSpecified())
       TRY_TO(TraverseTemplateArgumentLocsHelper(
           TC->getTemplateArgsAsWritten()->getTemplateArgs(),
           TC->getTemplateArgsAsWritten()->NumTemplateArgs));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
     TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
 })
 
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->getTemplateArgsAsWritten()->getTemplateArgs(),
           S->getTemplateArgsAsWritten()->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.isTypeConstraint())
+        TRY_TO(TraverseTemplateParameterListHelper(
+                   RetReq.getTypeConstraintTemplateParameterList()));
+    } 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(FixedPointLiteral, {})
 DEF_TRAVERSE_STMT(CharacterLiteral, {})
 DEF_TRAVERSE_STMT(FloatingLiteral, {})
 DEF_TRAVERSE_STMT(ImaginaryLiteral, {})
 DEF_TRAVERSE_STMT(StringLiteral, {})
 DEF_TRAVERSE_STMT(ObjCStringLiteral, {})

include/clang/Basic/DeclNodes.td

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

include/clang/Basic/DiagnosticIDs.h

namespace clang {
   namespace diag {
     // Size of each of the diagnostic categories.
     enum {
       DIAG_SIZE_COMMON        =  300,
       DIAG_SIZE_DRIVER        =  200,
       DIAG_SIZE_FRONTEND      =  150,
       DIAG_SIZE_SERIALIZATION =  120,
       DIAG_SIZE_LEX           =  400,
-      DIAG_SIZE_PARSE         =  500,
+      DIAG_SIZE_PARSE         =  600,
       DIAG_SIZE_AST           =  150,
       DIAG_SIZE_COMMENT       =  100,
       DIAG_SIZE_CROSSTU       =  100,
-      DIAG_SIZE_SEMA          = 3500,
+      DIAG_SIZE_SEMA          = 3600,
       DIAG_SIZE_ANALYSIS      =  100,
       DIAG_SIZE_REFACTORING   = 1000,
     };
     // Start position for diagnostics.
     enum {
       DIAG_START_COMMON        =                          0,
       DIAG_START_DRIVER        = DIAG_START_COMMON        + DIAG_SIZE_COMMON,
       DIAG_START_FRONTEND      = DIAG_START_DRIVER        + DIAG_SIZE_DRIVER,

include/clang/Basic/DiagnosticParseKinds.td

def err_template_defn_explicit_instantiation : Error<
   "%select{function|class|variable}0 cannot be defined in an explicit instantiation; if this "
   "declaration is meant to be a %select{function|class|variable}0 definition, remove the 'template' keyword">;
 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 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_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_auto_not_allowed_in_return_type_requirement : Error<
+  "%select{'auto'|'decltype(auto)'|'__auto_type'}0 not allowed in expression "
+  "type requirement">;
 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<
   "when substituting into %0 %1. Make sure concept arguments are "
   "valid for any substitution">;
 def err_constrained_virtual_method : Error<
   "virtual function cannot 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_expr_unknown_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid">;
+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_type_requirement_unknown_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid">;
+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_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 note_type_requirement_unknown_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid">;
+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 note_nested_requirement_unknown_substitution_error : Note<
+  "%select{and|because}0 '%1' would be invalid">;
 def note_ambiguous_atomic_constraints : Note<
   "'%0' in the two declarations is not considered equivalent - move it to a "
   "concept and reference it from here:">;
 def note_ambiguous_atomic_constraints_second : Note<"and here">;
 
 def err_template_different_requires_clause : Error<
   "requires clause differs in template redeclaration">;
 def err_template_different_type_constraint : Error<
   "type constraint differs in template redeclaration">;
 def err_template_template_parameter_not_at_least_as_constrained : Error<
   "template template argument %0 must not be more constrained than template "
   "template parameter %1">;
 
 def err_type_constraint_non_type_concept : Error<
   "concept named in type constraint must be a type concept">;
 def err_type_constraint_missing_arguments : Error<
   "%0 requires more than 1 template argument; provide the remaining arguments "
   "explicitly to use it here">;
 
 // 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">;
def note_deduced_template_arg_substitution_here : Note<
   "%select{partial specialization |}1%2 %3">;
 def note_prior_template_arg_substitution : Note<
   "while substituting prior template arguments into %select{non-type|template}0"
   " template parameter%1 %2">;
 def note_template_default_arg_checking : Note<
   "while checking a default template argument used here">;
 def note_concept_specialization_here : Note<
   "while checking the satisfaction of concept '%0' requested here">;
+def note_nested_requirement_here : Note<
+  "while checking the satisfaction of nested requirement requested here">;
 def note_checking_constraints_for_template_id_here : Note<
   "while checking constraint satisfaction for template '%0' required here">;
 def note_checking_constraints_for_var_spec_id_here : Note<
   "while checking constraint satisfaction for variable template "
   "partial specialization '%0' required here">;
 def note_checking_constraints_for_class_spec_id_here : Note<
   "while checking constraint satisfaction for class template partial "
   "specialization '%0' required 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

private:
   //===--------------------------------------------------------------------===//
   // C++ Coroutines
 
   ExprResult ParseCoyieldExpression();
 
   //===--------------------------------------------------------------------===//
   // C++ Concepts
 
+  ExprResult ParseRequiresExpression();
   void ParseTrailingRequiresClause(Declarator &D);
 
   //===--------------------------------------------------------------------===//
   // C99 6.7.8: Initialization.
 
   /// ParseInitializer
   ///       initializer: [C99 6.7.8]
   ///         assignment-expression
void InitCXXThisScopeForDeclaratorIfRelevant(const Declarator &D,
       const DeclSpec &DS, llvm::Optional<Sema::CXXThisScopeRAII> &ThisScope);
   bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
                          SourceLocation &RefQualifierLoc);
   bool isFunctionDeclaratorIdentifierList();
   void ParseFunctionDeclaratorIdentifierList(
          Declarator &D,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
   void ParseParameterDeclarationClause(
-         Declarator &D,
+         DeclaratorContext DeclaratorContext,
          ParsedAttributes &attrs,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
          SourceLocation &EllipsisLoc);
   void ParseBracketDeclarator(Declarator &D);
   void ParseMisplacedBracketDeclarator(Declarator &D);
 
   //===--------------------------------------------------------------------===//
   // C++ 7: Declarations [dcl.dcl]

include/clang/Sema/DeclSpec.h

enum class DeclaratorContext {
     LambdaExprContext,   // Lambda-expression declarator.
     LambdaExprParameterContext, // Lambda-expression parameter declarator.
     ConversionIdContext, // C++ conversion-type-id.
     TrailingReturnContext, // C++11 trailing-type-specifier.
     TrailingReturnVarContext, // C++11 trailing-type-specifier for variable.
     TemplateArgContext,  // Any template argument (in template argument list).
     TemplateTypeArgContext, // Template type argument (in default argument).
     AliasDeclContext,    // C++11 alias-declaration.
-    AliasTemplateContext // C++11 alias-declaration template.
+    AliasTemplateContext, // C++11 alias-declaration template.
+    RequiresExprContext   // C++2a requires-expression.
 };
 
 
 /// Information about one declarator, including the parsed type
 /// information and the identifier.
 ///
 /// When the declarator is fully formed, this is turned into the appropriate
 /// Decl object.
bool mayOmitIdentifier() const {
     case DeclaratorContext::ObjCCatchContext:
     case DeclaratorContext::BlockLiteralContext:
     case DeclaratorContext::LambdaExprContext:
     case DeclaratorContext::ConversionIdContext:
     case DeclaratorContext::TemplateArgContext:
     case DeclaratorContext::TemplateTypeArgContext:
     case DeclaratorContext::TrailingReturnContext:
     case DeclaratorContext::TrailingReturnVarContext:
+    case DeclaratorContext::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 DeclaratorContext::FileContext:
     case DeclaratorContext::KNRTypeListContext:
     case DeclaratorContext::MemberContext:
     case DeclaratorContext::BlockContext:
     case DeclaratorContext::ForContext:
     case DeclaratorContext::InitStmtContext:
     case DeclaratorContext::ConditionContext:
     case DeclaratorContext::PrototypeContext:
     case DeclaratorContext::LambdaExprParameterContext:
     case DeclaratorContext::TemplateParamContext:
     case DeclaratorContext::CXXCatchContext:
     case DeclaratorContext::ObjCCatchContext:
+    case DeclaratorContext::RequiresExprContext:
       return true;
 
     case DeclaratorContext::TypeNameContext:
     case DeclaratorContext::FunctionalCastContext:
     case DeclaratorContext::CXXNewContext:
     case DeclaratorContext::AliasDeclContext:
     case DeclaratorContext::AliasTemplateContext:
     case DeclaratorContext::ObjCParameterContext:
bool mayHaveDecompositionDeclarator() const {
     case DeclaratorContext::ForContext:
     case DeclaratorContext::InitStmtContext:
     case DeclaratorContext::ConditionContext:
       return true;
 
     case DeclaratorContext::MemberContext:
     case DeclaratorContext::PrototypeContext:
     case DeclaratorContext::TemplateParamContext:
+    case DeclaratorContext::RequiresExprContext:
       // Maybe one day...
       return false;
 
     // These contexts don't allow any kind of non-abstract declarator.
     case DeclaratorContext::KNRTypeListContext:
     case DeclaratorContext::TypeNameContext:
     case DeclaratorContext::FunctionalCastContext:
     case DeclaratorContext::AliasDeclContext:
bool mayBeFollowedByCXXDirectInit() const {
     case DeclaratorContext::AliasDeclContext:
     case DeclaratorContext::AliasTemplateContext:
     case DeclaratorContext::BlockLiteralContext:
     case DeclaratorContext::LambdaExprContext:
     case DeclaratorContext::ConversionIdContext:
     case DeclaratorContext::TemplateArgContext:
     case DeclaratorContext::TemplateTypeArgContext:
     case DeclaratorContext::TrailingReturnContext:
+    case DeclaratorContext::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 DeclaratorContext::ObjCCatchContext:
     case DeclaratorContext::BlockLiteralContext:
     case DeclaratorContext::LambdaExprContext:
     case DeclaratorContext::ConversionIdContext:
     case DeclaratorContext::TemplateArgContext:
     case DeclaratorContext::TemplateTypeArgContext:
     case DeclaratorContext::TrailingReturnContext:
     case DeclaratorContext::TrailingReturnVarContext:
+    case DeclaratorContext::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 DeclaratorContext::CXXCatchContext:
     case DeclaratorContext::ObjCCatchContext:
     case DeclaratorContext::BlockLiteralContext:
     case DeclaratorContext::LambdaExprContext:
     case DeclaratorContext::ConversionIdContext:
     case DeclaratorContext::TrailingReturnContext:
     case DeclaratorContext::TrailingReturnVarContext:
     case DeclaratorContext::TemplateTypeArgContext:
+    case DeclaratorContext::RequiresExprContext:
       return false;
 
     case DeclaratorContext::BlockContext:
     case DeclaratorContext::ForContext:
     case DeclaratorContext::InitStmtContext:
     case DeclaratorContext::ConditionContext:
     case DeclaratorContext::TemplateArgContext:
       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,
                                              SourceRange TemplateIDRange);
 
   /// \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);

   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 NameLoc, Expr *ConstraintExpr);
 
+  RequiresExprBodyDecl *
+  ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc,
+                         ArrayRef<ParmVarDecl *> LocalParameters,
+                         Scope *BodyScope);
+  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,
+                                        TemplateIdAnnotation *TypeConstraint,
+                                        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 *PParam, 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 computing the exception specification for a defaulted special
       /// member function.
       ExceptionSpecEvaluation,
 
       /// 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 checking the satisfaction of a nested requirement of a requires
+      /// expression.
+      NestedRequirementConstraintsCheck,
+
       /// We are declaring an implicit special member function.
       DeclaringSpecialMember,
 
       /// We are defining a synthesized function (such as a defaulted special
       /// member).
       DefiningSynthesizedFunction,
 
       // We are checking the constraints associated with a constrained entity or
struct InstantiatingTemplate {
     /// \brief Note that we are checking a constraint expression associated
     /// with a template declaration or as part of the satisfaction check of a
     /// concept.
     InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
                           ConstraintSubstitution, NamedDecl *Template,
                           sema::TemplateDeductionInfo &DeductionInfo,
                           SourceRange InstantiationRange);
 
+    /// \brief Note that we are substituting template arguments into a part of
+    /// a requirement of a requires expression.
+    InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                          Requirement *Req,
+                          sema::TemplateDeductionInfo &DeductionInfo,
+                          SourceRange InstantiationRange = SourceRange());
+
+    /// \brief Note that we are checking the satisfaction of the constraint
+    /// expression inside of a nested requirement.
+    InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                          NestedRequirement *Req, ConstraintsCheck,
+                          SourceRange InstantiationRange = SourceRange());
+
     /// Note that we have finished instantiating this template.
     void Clear();
 
     ~InstantiatingTemplate() { Clear(); }
 
     /// Determines whether we have exceeded the maximum
     /// recursive template instantiations.
     bool isInvalid() const { return Invalid; }

include/clang/Sema/SemaConcept.h

 /// \brief This file provides some common utilities for processing constraints
 /// and concepts.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_SEMA_SEMACONCEPTS_H
 #define LLVM_CLANG_SEMA_SEMACONCEPTS_H
 #include "clang/AST/Expr.h"
+#include "clang/AST/DeclTemplate.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_ConstraintsNotSatisfied,
+      SS_Satisfied
+  };
+  class ReturnTypeRequirement {
+      using TypeConstraintRequirement = std::pair<TemplateParameterList *,
+                                                  ConceptSpecializationExpr *>;
+      bool Dependent : 1;
+      bool ContainsUnexpandedParameterPack : 1;
+      llvm::PointerUnion3<TypeConstraintRequirement *, 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 'type constraint' style return type requirement.
+      /// \param TPL an invented template parameter list containing a single
+      /// type parameter with a type-constraint.
+      /// \param TypeConstraint the type constraint specified in the
+      /// requirement.
+      /// \param CSE a pre-instantiated constraint expression. Should only be
+      /// passed by ASTStmtReader.
+      ReturnTypeRequirement(ASTContext &C, TemplateParameterList *TPL,
+                            ConceptSpecializationExpr *CSE = nullptr);
+
+      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 isTypeConstraint() const {
+        return Value && Value.is<TypeConstraintRequirement *>();
+      }
+
+      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 *>();
+      }
+
+      const TypeConstraint *getTypeConstraint() const {
+        assert(isTypeConstraint());
+        auto &Req = *Value.get<TypeConstraintRequirement *>();
+        return cast<TemplateTypeParmDecl>(Req.first->getParam(0))
+            ->getTypeConstraint();
+      }
+
+      TemplateParameterList *getTypeConstraintTemplateParameterList() const {
+        assert(isTypeConstraint());
+        return Value.get<TypeConstraintRequirement *>()->first;
+      }
+
+      ConceptSpecializationExpr *
+      getTypeConstraintSubstitutedConstraintExpr() const {
+        assert(isTypeConstraint());
+        return Value.get<TypeConstraintRequirement *>()->second;
+      }
+
+      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 ObjCCategory:
     case ObjCCategoryImpl:
     case Import:
     case OMPThreadPrivate:
     case OMPAllocate:
     case OMPRequires:
     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() {
   case Decl::TranslationUnit:
   case Decl::ExternCContext:
   case Decl::LinkageSpec:
   case Decl::Export:
   case Decl::Block:
   case Decl::Captured:
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
+  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 ConstantExprClass:
     // FIXME: Move this into the "return false;" block above.
     return cast<ConstantExpr>(this)->getSubExpr()->HasSideEffects(
         Ctx, IncludePossibleEffects);
 

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 {

 }
 
 ConceptSpecializationExpr *
 ConceptSpecializationExpr::Create(ASTContext &C, EmptyShell Empty,
                                   unsigned NumTemplateArgs) {
   void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
                                 NumTemplateArgs));
   return new (Buffer) ConceptSpecializationExpr(Empty, NumTemplateArgs);
+}
+
+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();
+      if (!IsSatisfied)
+        break;
+    }
+  }
+  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;
 
   case Expr::ConstantExprClass:
     return ClassifyInternal(Ctx, cast<ConstantExpr>(E)->getSubExpr());
 
     // Next come the complicated cases.
   case Expr::SubstNonTypeTemplateParmExprClass:
     return ClassifyInternal(Ctx,

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
 };
 
 class FixedPointExprEvaluator
     : public ExprEvaluatorBase<FixedPointExprEvaluator> {
   APValue &Result;
 
  public:
bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
   return Success(E->getValue(), E);
 }
 
 bool IntExprEvaluator::VisitConceptSpecializationExpr(
        const ConceptSpecializationExpr *E) {
   return Success(E->isSatisfied(), E);
 }
 
+bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) {
+  if (E->isValueDependent()) {
+    return Error(E);
+  }
+  return Success(E->isSatisfied(), E);
+}
+
 
 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
   switch (E->getOpcode()) {
     default:
       // Invalid unary operators
       return Error(E);
     case UO_Plus:
       // The result is just the value.
#include "clang/AST/StmtNodes.inc"
   case Expr::IntegerLiteralClass:
   case Expr::FixedPointLiteralClass:
   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::ObjCIndirectCopyRestoreExprClass:
   case Expr::ObjCAvailabilityCheckExprClass:
   case Expr::OffsetOfExprClass:
   case Expr::PredefinedExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::TypeTraitExprClass:
+  case Expr::RequiresExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::FixedPointLiteralClass:

lib/AST/StmtPrinter.cpp

if (NNS)
     NNS.getNestedNameSpecifier()->print(OS, Policy);
   if (E->getTemplateKWLoc().isValid())
     OS << "template ";
   OS << E->getFoundDecl()->getName();
   printTemplateArgumentList(OS, E->getTemplateArgsAsWritten()->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.isTypeConstraint())
+            RetReq.getTypeConstraint()->print(OS, Policy);
+        }
+      }
+    } 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->getTemplateArgsAsWritten()->getTemplateArgs(),
                          S->getTemplateArgsAsWritten()->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.isTypeConstraint()) {
+        ID.AddInteger(2);
+        Visit(RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint());
+      } 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::Label:        // __label__ x;
   case Decl::Import:
   case Decl::OMPThreadPrivate:
   case Decl::OMPAllocate:
   case Decl::OMPCapturedExpr:
   case Decl::OMPRequires:
   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/Frontend/FrontendActions.cpp

static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
     case CodeSynthesisContext::DefiningSynthesizedFunction:
       return "DefiningSynthesizedFunction";
     case CodeSynthesisContext::Memoization:
       return "Memoization";
     case CodeSynthesisContext::ConstraintsCheck:
       return "ConstraintsCheck";
     case CodeSynthesisContext::ConstraintSubstitution:
       return "ConstraintSubstitution";
+    case CodeSynthesisContext::RequirementInstantiation:
+      return "RequirementInstantiation";
+    case CodeSynthesisContext::NestedRequirementConstraintsCheck:
+      return "NestedRequirementConstraintsCheck";
     }
     return "";
   }
 
   template <bool BeginInstantiation>
   static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
                                     const CodeSynthesisContext &Inst) {
     std::string YAML;

lib/Frontend/InitPreprocessor.cpp

if (!LangOpts.CPlusPlus) {
     else if (LangOpts.CPlusPlus11)
       Builder.defineMacro("__cplusplus", "201103L");
     // C++03 [cpp.predefined]p1:
     //   The name __cplusplus is defined to the value 199711L when compiling a
     //   C++ translation unit.
     else
       Builder.defineMacro("__cplusplus", "199711L");
 
+    if (LangOpts.ConceptsTS)
+      Builder.defineMacro("__cpp_concepts", "201707L");
+
     // C++1z [cpp.predefined]p1:
     //   An integer literal of type std::size_t whose value is the alignment
     //   guaranteed by a call to operator new(std::size_t)
     //
     // We provide this in all language modes, since it seems generally useful.
     Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
                         Twine(TI.getNewAlign() / TI.getCharWidth()) +
                             TI.getTypeConstantSuffix(TI.getSizeType()));

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,
+       DeclaratorContext 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() == DeclaratorContext::LambdaExprContext
+        DS, DeclaratorContext == DeclaratorContext::RequiresExprContext
+                ? DeclaratorContext::RequiresExprContext
+                : DeclaratorContext == DeclaratorContext::LambdaExprContext
                       ? DeclaratorContext::LambdaExprParameterContext
                       : DeclaratorContext::PrototypeContext);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.
     MaybeParseGNUAttributes(ParmDeclarator);
 
     if (Tok.is(tok::kw_requires)) {
       // User tried to define a requires clause in a parameter declaration,
       // which is surely not a function declaration.
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() == DeclaratorContext::MemberContext) {
+        if (DeclaratorContext == DeclaratorContext::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__'
 /// [MS]    '__FUNCSIG__'
 /// [MS]    'L__FUNCSIG__'
 /// [GNU]   '__PRETTY_FUNCTION__'
 /// [GNU]   '(' compound-statement ')'
if (EnsureNotPrimary())
       return ExprError();
     return ParseCXXNewExpression(false, Tok.getLocation());
 
   case tok::kw_delete: // [C++] delete-expression
     if (EnsureNotPrimary())
       return ExprError();
     return ParseCXXDeleteExpression(false, Tok.getLocation());
 
+  case tok::kw_requires: // [C++2a] requires-expression
+    return ParseRequiresExpression();
+
   case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')'
     if (EnsureNotPrimary())
       return ExprError();
     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"))

lib/Parse/ParseExprCXX.cpp

 //===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // 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"
bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
                                             bool IsTypename,
                                             IdentifierInfo **LastII,
                                             bool OnlyNamespace,
                                             bool SuppressDiagnostic) {
   assert(getLangOpts().CPlusPlus &&
          "Call sites of this function should be guarded by checking for C++");
 
   if (Tok.is(tok::annot_cxxscope)) {
     assert(!LastII && "want last identifier but have already annotated scope");
     assert(!LastII && "want last identifier but have already annotated scope");
     assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
     Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
                                                  Tok.getAnnotationRange(),
                                                  SS);
     ConsumeAnnotationToken();
     return false;
   }
 
if (Next.is(tok::coloncolon)) {
       continue;
     }
 
     CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
 
     // nested-name-specifier:
     //   type-name '<'
     if (Next.is(tok::less)) {
       if (OnlyNamespace)
         // We can't have template-ids as part of a namespace scope specifier,
         // the scope specifier must end here.
         break;
 
       TemplateTy Template;
       UnqualifiedId TemplateName;
       TemplateName.setIdentifier(&II, Tok.getLocation());
       bool MemberOfUnknownSpecialization;
       if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
                                               /*hasTemplateKeyword=*/false,
                                                         TemplateName,
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);
-      // For a generic lambda, each 'auto' within the parameter declaration
+      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(AnyCastExpr));
   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'
+
+  llvm::SmallVector<ParmVarDecl *, 2> LocalParameterDecls;
+  if (Tok.is(tok::l_paren)) {
+    // requirement parameter list is present.
+    ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope |
+                                    Scope::DeclScope);
+    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(DeclaratorContext::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;
+
+  // C++2a [expr.prim.req]p2
+  //   Expressions appearing within a requirement-body are unevaluated operands.
+  EnterExpressionEvaluationContext Ctx(
+      Actions, Sema::ExpressionEvaluationContext::Unevaluated);
+
+  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();
+  }
+
+  ParseScope BodyScope(this, Scope::DeclScope);
+  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 ((TemplateKWLoc.isValid() &&
+           TypeName.getKind() != UnqualifiedIdKind::IK_TemplateId) ||
+          (TemplateKWLoc.isInvalid() &&
+           TypeName.getKind() != UnqualifiedIdKind::IK_Identifier &&
+           TypeName.getKind() != UnqualifiedIdKind::IK_TemplateId)) {
+        Diag(IdLoc, diag::err_requires_expr_type_req_illegal_identifier);
+        Braces.skipToEnd();
+        Actions.ActOnExitRequiresExpr();
+        return ExprError();
+      }
+      if (TypeName.getKind() == UnqualifiedIdKind::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 =
+          Actions.CorrectDelayedTyposInExpr(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 'type-constraint' requirement first.
+      auto TryTypeConstraint = [&] {
+        Token ArrowToken = Tok;
+        ConsumeToken(); // Consume the arrow
+        bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
+        CXXScopeSpec SS;
+        bool ScopeError =
+            ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
+                                           /*EnteringContext=*/false,
+                                           /*MayBePseudoDestructor=*/nullptr,
+                                           // If this is not a type-constraint,
+                                           // then this scope-spec is part of
+                                           // the typename of a non-type
+                                           // template parameter
+                                           /*IsTypename=*/true,
+                                           /*LastII=*/nullptr,
+                                           // We won't find concepts in
+                                           // non-namespaces anyway, so might as
+                                           // well parse this correctly for
+                                           // possible type names.
+                                           /*OnlyNamespace=*/false,
+                                           /*SuppressDiagnostic=*/true);
+        if (ScopeError)
+          return true;
+        if (!TryAnnotateTypeConstraint(SS)) {
+          if (SS.isNotEmpty())
+            // This isn't a type-constraint but we've already parsed this scope
+            // specifier - annotate it.
+            AnnotateScopeToken(SS, /*isNewAnnotation=*/!WasScopeAnnotation);
+          UnconsumeToken(ArrowToken);
+          return false;
+        }
+        if (NextToken().isOneOf(tok::kw_auto, tok::kw_decltype)) {
+          // This type-constraint is part of a placeholder - leave it annotated
+          // and parse a normal trailing-return-type
+          UnconsumeToken(ArrowToken);
+          return false;
+        }
+
+        Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc,
+                                               takeTemplateIdAnnotation(Tok),
+                                               TemplateParameterDepth);
+        ConsumeAnnotationToken();
+        return true;
+      };
+
+      if (!TryTypeConstraint()) {
+        SourceRange Range(Tok.getLocation(), FindSemi());
+        TypeResult ExpectedType =
+            ParseTrailingReturnType(Range, /*MayBeFollowedByDirectInit=*/false);
+        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 =
+          Actions.CorrectDelayedTyposInExpr(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 =
+          Actions.CorrectDelayedTyposInExpr(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/Sema.cpp

 //===----------------------------------------------------------------------===//
 // Helper functions.
 //===----------------------------------------------------------------------===//
 
 DeclContext *Sema::getFunctionLevelDeclContext() {
   DeclContext *DC = CurContext;
 
   while (true) {
-    if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
+    if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC) ||
+        isa<RequiresExprBodyDecl>(DC)) {
       DC = DC->getParent();
     } else if (isa<CXXMethodDecl>(DC) &&
                cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
                cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
       DC = DC->getParent()->getParent();
     }
     else break;
   }

lib/Sema/SemaConcept.cpp

 //===-- SemaConcept.cpp - Semantic Analysis for Constraints and Concepts --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ constraints and concepts.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaDiagnostic.h"
+#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,
                                      Expr **Culprit) {
if (CSE->getTemplateArgsAsWritten()->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)) {
+    for (Requirement *Req : RE->getRequirements())
+      if (!Req->isDependent() && !Req->isSatisfied()) {
+        Req->Diagnose(S, First);
+        break;
+      }
+    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(const Expr *ConstraintExpr,
for (const auto &Qj : QCNF) {
         return false;
       }
     }
   }
   DoesSubsume = true;
   return false;
 }
 
 bool Sema::IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
                                   NamedDecl *D2, ArrayRef<const Expr *> AC2,
                                   bool NoCache) {
   if (AC1.empty())
     return AC2.empty();
   if (AC2.empty())
     // TD1 has associated constraints and TD2 does not.
     return true;
 
   std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
   if (!NoCache) {
     auto CacheEntry = SubsumptionCache.find(Key);
bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
   Diag(AmbiguousAtomic1->getBeginLoc(), diag::note_ambiguous_atomic_constraints)
       << const_cast<Expr *>(AmbiguousAtomic1)
       << AmbiguousAtomic1->getSourceRange();
   Diag(AmbiguousAtomic2->getBeginLoc(),
        diag::note_ambiguous_atomic_constraints_second)
       << AmbiguousAtomic2->getSourceRange();
   return true;
 }
+
+
+
+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) {}
+
+ExprRequirement::ReturnTypeRequirement::ReturnTypeRequirement(ASTContext &C,
+    TemplateParameterList *TPL, ConceptSpecializationExpr *CSE) :
+    Dependent(false), ContainsUnexpandedParameterPack(false),
+    Value(new (C) TypeConstraintRequirement(TPL, CSE)) {
+  assert(TPL->size() == 1);
+  const TypeConstraint *TC =
+      cast<TemplateTypeParmDecl>(TPL->getParam(0))->getTypeConstraint();
+  assert(TC &&
+         "TPL must have a template type parameter with a type constraint");
+  auto *Constraint =
+      cast_or_null<ConceptSpecializationExpr>(
+          TC->getImmediatelyDeclaredConstraint());
+  ContainsUnexpandedParameterPack =
+      Constraint->containsUnexpandedParameterPack();
+  for (auto &ArgLoc :
+       Constraint->getTemplateArgsAsWritten()->arguments().drop_front(1))
+    if (ArgLoc.getArgument().isDependent()) {
+      Dependent = true;
+      break;
+    }
+}
+
+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 *>()) {
+    InitializedEntity InventedEntity =
+        InitializedEntity::InitializeResult(TypeReq->getTypeLoc().getBeginLoc(),
+                                            TypeReq->getType(), /*NRVO=*/false);
+    InitializationSequence Seq(S, InventedEntity,
+        InitializationKind::CreateCopy(E->getBeginLoc(),
+                                       TypeReq->getTypeLoc().getBeginLoc()), E);
+    if (Seq.isAmbiguous())
+      return SS_ImplicitConversionAmbiguous;
+    if (Seq.Failed())
+      return SS_NoImplicitConversionExists;
+    return SS_Satisfied;
+  }
+  auto *TypeConstr = Value.get<TypeConstraintRequirement *>();
+  TemplateParameterList *TPL = TypeConstr->first;
+
+  // C++2a [expr.prim.req]p1.3.3
+  //     The immediately-declared constraint ([temp]) of decltype((E)) shall be
+  //     satisfied.
+  QualType MatchedType =
+      S.BuildDecltypeType(E, E->getBeginLoc()).getCanonicalType();
+  llvm::SmallVector<TemplateArgument, 1> Args;
+  Args.push_back(TemplateArgument(MatchedType));
+  TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args);
+  MultiLevelTemplateArgumentList MLTAL(TAL);
+  for (unsigned I = 0; I < TPL->getDepth(); ++I)
+    MLTAL.addOuterRetainedLevel();
+  ExprResult Constraint =
+      S.SubstExpr(cast<TemplateTypeParmDecl>(
+          TPL->getParam(0))->getTypeConstraint()
+          ->getImmediatelyDeclaredConstraint(), 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());
+  TypeConstr->second = 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();
+    if (!SubstDiag->DiagMessage.empty())
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_expr_requirement_expr_substitution_error) << (int)First
+          << SubstDiag->SubstitutedEntity
+          << SubstDiag->DiagMessage;
+    else
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_expr_requirement_expr_unknown_substitution_error)
+            << (int)First << SubstDiag->SubstitutedEntity;
+    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();
+    if (!SubstDiag->DiagMessage.empty())
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_expr_requirement_type_requirement_substitution_error)
+          << (int)First << SubstDiag->SubstitutedEntity
+          << SubstDiag->DiagMessage;
+    else
+      S.Diag(SubstDiag->DiagLoc,
+        diag::note_expr_requirement_type_requirement_unknown_substitution_error)
+          << (int)First << SubstDiag->SubstitutedEntity;
+    break;
+  }
+  case SS_ImplicitConversionAmbiguous:
+    S.Diag(TypeReq.getTrailingReturnTypeExpectedType()
+               ->getTypeLoc().getBeginLoc(),
+           diag::note_expr_requirement_ambiguous_conversion) << (int)First
+        << getExpr()->getType()
+        << TypeReq.getTrailingReturnTypeExpectedType()
+            ->getType();
+    break;
+  case SS_NoImplicitConversionExists:
+    S.Diag(TypeReq.getTrailingReturnTypeExpectedType()
+               ->getTypeLoc().getBeginLoc(),
+           diag::note_expr_requirement_no_implicit_conversion) << (int)First
+        << getExpr()->getType()
+        << TypeReq.getTrailingReturnTypeExpectedType()
+            ->getType();
+    break;
+  case SS_ConstraintsNotSatisfied: {
+    ConceptSpecializationExpr *ConstraintExpr =
+        TypeReq.getTypeConstraintSubstitutedConstraintExpr();
+    if (ConstraintExpr->getTemplateArgsAsWritten()->NumTemplateArgs == 1)
+      // A simple case - expr type is the type being constrained and the concept
+      // was not provided arguments.
+      S.Diag(ConstraintExpr->getBeginLoc(),
+           diag::note_expr_requirement_constraints_not_satisfied_simple)
+          << (int)First << getExpr()->getType()
+          << ConstraintExpr->getNamedConcept();
+    else
+      S.Diag(ConstraintExpr->getBeginLoc(),
+             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();
+    if (!SubstDiag->DiagMessage.empty())
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_type_requirement_substitution_error) << (int)First
+          << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    else
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_type_requirement_unknown_substitution_error)
+          << (int)First << SubstDiag->SubstitutedEntity;
+    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();
+    if (!SubstDiag->DiagMessage.empty())
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_nested_requirement_substitution_error) << (int)First
+          << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage;
+    else
+      S.Diag(SubstDiag->DiagLoc,
+             diag::note_nested_requirement_unknown_substitution_error)
+          << (int)First << SubstDiag->SubstitutedEntity;
+    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) ||
       isa<OMPDeclareMapperDecl>(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) || isa<OMPDeclareMapperDecl>(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()) &&
+      !isUnevaluatedContext()) {
+    // C++ [expr.prim.req.nested] p3
+    //   A local parameter shall only appear as an unevaluated operand
+    //   (Clause 8) within the constraint-expression.
+    Diag(NameInfo.getBeginLoc(),
+         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,
   // Check for an unexpanded parameter pack.
   auto UPPC = IsIfExists ? UPPC_IfExists : UPPC_IfNotExists;
   if (DiagnoseUnexpandedParameterPack(SS, UPPC) ||
       DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC))
     return IER_Error;
 
   return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo);
 }
+
+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() == UnqualifiedIdKind::IK_TemplateId ||
+          TypeName.getKind() == UnqualifiedIdKind::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) {
+  if (ExpectedType->getType().getTypePtr()->isUndeducedType()) {
+    auto *Auto = ExpectedType->getType()->getContainedAutoType();
+    Diag(ExpectedType->getTypeLoc().getBeginLoc(),
+         diag::err_auto_not_allowed_in_return_type_requirement)
+        << (unsigned)Auto->getKeyword();
+    return nullptr;
+  }
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+             NoexceptLoc, ExprRequirement::ReturnTypeRequirement(Context,
+                                                                 ExpectedType));
+}
+
+Requirement *
+Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc,
+                               TemplateIdAnnotation *TypeConstraint,
+                               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,
+                                              /*HasTypeConstraint=*/true);
+
+  if (ActOnTypeConstraint(TypeConstraint, TParam,
+                          /*EllpsisLoc=*/SourceLocation()))
+    // Just produce a requirement with no type requirements.
+    return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+      NoexceptLoc, ExprRequirement::ReturnTypeRequirement());
+
+  auto *TPL = TemplateParameterList::Create(Context, SourceLocation(),
+                                            SourceLocation(),
+                                            ArrayRef<NamedDecl *>(TParam),
+                                            SourceLocation(),
+                                            /*RequiresClause=*/nullptr);
+
+  return new (Context) ExprRequirement(*this, E, /*IsSimple=*/false,
+      NoexceptLoc, ExprRequirement::ReturnTypeRequirement(Context, TPL));
+}
+
+Requirement *Sema::ActOnNestedRequirement(Expr *Constraint) {
+  return new (Context) NestedRequirement(*this, Constraint);
+}
+
+RequiresExprBodyDecl *
+Sema::ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc,
+                             ArrayRef<ParmVarDecl *> LocalParameters,
+                             Scope *BodyScope) {
+  assert(BodyScope);
+
+  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(BodyScope, 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(BodyScope, Param);
+
+      PushOnScopeChains(Param, BodyScope);
+
+      // Verify that the argument identifier has not already been mentioned.
+      if (!ParamsSoFar.insert(Param->getIdentifier()).second)
+        Diag(Param->getBeginLoc(), 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;
 }
 
 /// Determine whether the module M is part of the current module from the

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(), TemplateParams->getDepth()};
+  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

 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "clang/Sema/TemplateInstCallback.h"
+#include "clang/Sema/SemaConcept.h"
 #include "llvm/Support/TimeProfiler.h"
 
 using namespace clang;
 using namespace sema;
 
 //===----------------------------------------------------------------------===/
 // Template Instantiation Support
 //===----------------------------------------------------------------------===/
bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   case TemplateInstantiation:
   case ExceptionSpecInstantiation:
   case DefaultTemplateArgumentInstantiation:
   case DefaultFunctionArgumentInstantiation:
   case ExplicitTemplateArgumentSubstitution:
   case DeducedTemplateArgumentSubstitution:
   case PriorTemplateArgumentSubstitution:
   case ConstraintsCheck:
+  case NestedRequirementConstraintsCheck:
     return true;
 
+  case RequirementInstantiation:
   case DefaultTemplateArgumentChecking:
   case DeclaringSpecialMember:
   case DefiningSynthesizedFunction:
   case ExceptionSpecEvaluation:
   case ConstraintSubstitution:
     return false;
 
   // This function should never be called when Kind's value is Memoization.
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;
     atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
   }
 }
 
 Sema::InstantiatingTemplate::InstantiatingTemplate(
Sema::InstantiatingTemplate::InstantiatingTemplate(
     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) {}
+
+
+Sema::InstantiatingTemplate::InstantiatingTemplate(
+    Sema &SemaRef, SourceLocation PointOfInstantiation, NestedRequirement *Req,
+    ConstraintsCheck, SourceRange InstantiationRange)
+    : InstantiatingTemplate(
+          SemaRef, CodeSynthesisContext::NestedRequirementConstraintsCheck,
+          PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr,
+          /*Template=*/nullptr, /*TemplateArgs=*/None) {}
+
+
+Sema::InstantiatingTemplate::InstantiatingTemplate(
     Sema &SemaRef, SourceLocation PointOfInstantiation,
     ConstraintsCheck, NamedDecl *Template,
     ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
     : InstantiatingTemplate(
           SemaRef, CodeSynthesisContext::ConstraintsCheck,
           PointOfInstantiation, InstantiationRange, Template, nullptr,
           TemplateArgs) {}
 
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));
     }
 
     atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
                   SemaRef.CodeSynthesisContexts.back());
 
     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::NestedRequirementConstraintsCheck:
+      Diags.Report(Active->PointOfInstantiation,
+                   diag::note_nested_requirement_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.
case CodeSynthesisContext::TemplateInstantiation:
       // An instantiation of an alias template may or may not be a SFINAE
       // context, depending on what else is on the stack.
       if (isa<TypeAliasTemplateDecl>(Active->Entity))
         break;
       LLVM_FALLTHROUGH;
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
     case CodeSynthesisContext::ExceptionSpecInstantiation:
     case CodeSynthesisContext::ConstraintsCheck:
+    case CodeSynthesisContext::NestedRequirementConstraintsCheck:
       // This is a template instantiation, so there is no SFINAE.
       return None;
 
     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
     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:
     case CodeSynthesisContext::ConstraintSubstitution:
-      // We're either substituting explicitly-specified template arguments
-      // or deduced template arguments or a constraint expression, so SFINAE
-      // applies.
+    case CodeSynthesisContext::RequirementInstantiation:
+      // We're either substituting explicitly-specified template arguments,
+      // deduced template arguments, a constraint expression 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);
+    }
+
+    bool TransformRequiresExprRequirements(ArrayRef<Requirement *> Reqs,
+        SmallVectorImpl<Requirement *> &Transformed) {
+      bool SatisfcationDetermined = false;
+      for (Requirement *Req : Reqs) {
+        Requirement *TransReq = nullptr;
+        if (!SatisfcationDetermined) {
+          if (auto *TypeReq = dyn_cast<TypeRequirement>(Req))
+            TransReq = TransformTypeRequirement(TypeReq);
+          else if (auto *ExprReq = dyn_cast<ExprRequirement>(Req))
+            TransReq = TransformExprRequirement(ExprReq);
+          else
+            TransReq = TransformNestedRequirement(cast<NestedRequirement>(Req));
+          if (!TransReq)
+            return true;
+          if (!TransReq->isDependent() && !TransReq->isSatisfied())
+            // [expr.prim.req]p6
+            //   [...]  The substitution and semantic constraint checking
+            //   proceeds in lexical order and stops when a condition that
+            //   determines the result of the requires-expression is
+            //   encountered. [..]
+            SatisfcationDetermined = true;
+        } else
+          TransReq = Req;
+        Transformed.push_back(TransReq);
+      }
+      return false;
+    }
+
     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) {
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) {
+  SmallString<128> Message;
+  SourceLocation ErrorLoc;
+  if (Info.hasSFINAEDiagnostic()) {
+    PartialDiagnosticAt PDA(SourceLocation(),
+                            PartialDiagnostic::NullDiagnostic{});
+    Info.takeSFINAEDiagnostic(PDA);
+    PDA.second.EmitToString(S.getDiagnostics(), Message);
+    ErrorLoc = PDA.first;
+  } else {
+    ErrorLoc = Info.getLocation();
+  }
+  std::string Str;
+  llvm::raw_string_ostream OS(Str);
+  Printer(OS);
+  return new (S.Context) Requirement::SubstitutionDiagnostic{OS.str(), ErrorLoc,
+                                                             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());
+  if (TypeInst.isInvalid())
+    return nullptr;
+  TypeSourceInfo *TransType = TransformType(Req->getType());
+  if (!TransType || Trap.hasErrorOccurred())
+    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()->getBeginLoc());
+
+  llvm::PointerUnion<Expr *, Requirement::SubstitutionDiagnostic *> TransExpr;
+  if (Req->isExprSubstitutionFailure())
+    TransExpr = Req->getExprSubstitutionDiagnostic();
+  else {
+    Sema::InstantiatingTemplate ExprInst(SemaRef, Req->getExpr()->getBeginLoc(),
+                                         Req, Info,
+                                         Req->getExpr()->getSourceRange());
+    if (ExprInst.isInvalid())
+      return nullptr;
+    ExprResult TransExprRes = TransformExpr(Req->getExpr());
+    if (TransExprRes.isInvalid() || Trap.hasErrorOccurred())
+      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());
+    if (TypeInst.isInvalid())
+      return nullptr;
+    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.isTypeConstraint()) {
+    TemplateParameterList *OrigTPL =
+        RetReq.getTypeConstraintTemplateParameterList();
+    Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(),
+                                        Req, Info, OrigTPL->getSourceRange());
+    if (TPLInst.isInvalid())
+      return nullptr;
+    TemplateParameterList *TPL =
+        TransformTemplateParameterList(OrigTPL);
+    if (!TPL)
+      TransRetReq.emplace(createSubstDiag(SemaRef, Info,
+          [&] (llvm::raw_string_ostream& OS) {
+              RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()
+                  ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy());
+          }));
+    else {
+      TPLInst.Clear();
+      TransRetReq.emplace(SemaRef.Context, TPL);
+    }
+  }
+  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::InstantiatingTemplate ReqInst(SemaRef,
+      Req->getConstraintExpr()->getBeginLoc(), Req,
+      Sema::InstantiatingTemplate::ConstraintsCheck{},
+      Req->getConstraintExpr()->getSourceRange());
+
+  ExprResult TransConstraint;
+  TemplateDeductionInfo Info(Req->getConstraintExpr()->getBeginLoc());
+  {
+    EnterExpressionEvaluationContext ContextRAII(
+        SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+    Sema::SFINAETrap Trap(SemaRef);
+    Sema::InstantiatingTemplate ConstrInst(SemaRef,
+        Req->getConstraintExpr()->getBeginLoc(), Req, Info,
+        Req->getConstraintExpr()->getSourceRange());
+    if (ConstrInst.isInvalid())
+      return nullptr;
+    TransConstraint = TransformExpr(Req->getConstraintExpr());
+    if (TransConstraint.isInvalid() || Trap.hasErrorOccurred())
+      return RebuildNestedRequirement(createSubstDiag(SemaRef, Info,
+          [&] (llvm::raw_string_ostream& OS) {
+              Req->getConstraintExpr()->printPretty(OS, nullptr,
+                                                    SemaRef.getPrintingPolicy());
+          }));
+  }
+  return RebuildNestedRequirement(TransConstraint.get());
+}
+
+
 /// 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

if (auto *TC = D->getTypeConstraint()) {
     if (TemplArgInfo) {
       InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
       InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
       if (SemaRef.Subst(TemplArgInfo->getTemplateArgs(),
                         TemplArgInfo->NumTemplateArgs,
                         InstArgs, TemplateArgs))
         return nullptr;
     }
     ExprResult Result =
         SemaRef.SubstExpr(TC->getImmediatelyDeclaredConstraint(), TemplateArgs);
     if (Result.isInvalid())
       return nullptr;
 
     Inst->setTypeConstraint(TC->getNestedNameSpecifierLoc(),
         TC->getConceptNameInfo(), TC->getFoundDecl(), TC->getNamedConcept(),
         TemplArgInfo ? ASTTemplateArgumentListInfo::Create(SemaRef.Context,
                                                            InstArgs) : nullptr,
         Result.get());
Decl *TemplateDeclInstantiator::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
 
   return nullptr;
 }
 
 Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
   llvm_unreachable("Concept definitions cannot reside inside a template");
 }
 
+Decl *
+TemplateDeclInstantiator::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
+  return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(),
+                                      D->getBeginLoc());
+}
+
 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 DeclaratorContext::LambdaExprContext:
       // Declared return type of a lambda-declarator is implicit and is always
       // 'auto'.
       break;
     case DeclaratorContext::ObjCParameterContext:
     case DeclaratorContext::ObjCResultContext:
     case DeclaratorContext::PrototypeContext:
       Error = 0;
       break;
+    case DeclaratorContext::RequiresExprContext:
+      Error = 21;
+      break;
     case DeclaratorContext::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 DeclaratorContext::TemplateTypeArgContext:
       DiagID = diag::err_type_defined_in_type_specifier;
       break;
     case DeclaratorContext::PrototypeContext:
     case DeclaratorContext::LambdaExprParameterContext:
     case DeclaratorContext::ObjCParameterContext:
     case DeclaratorContext::ObjCResultContext:
     case DeclaratorContext::KNRTypeListContext:
+    case DeclaratorContext::RequiresExprContext:
       // C++ [dcl.fct]p6:
       //   Types shall not be defined in return or parameter types.
       DiagID = diag::err_type_defined_in_param_type;
       break;
     case DeclaratorContext::ConditionContext:
       // C++ 6.4p2:
       // The type-specifier-seq shall not contain typedef and shall not declare
       // a new class or enumeration.
if (IsTypedefName) {
     case DeclaratorContext::LambdaExprContext:
     case DeclaratorContext::LambdaExprParameterContext:
     case DeclaratorContext::ObjCCatchContext:
     case DeclaratorContext::TemplateParamContext:
     case DeclaratorContext::TemplateArgContext:
     case DeclaratorContext::TemplateTypeArgContext:
     case DeclaratorContext::TypeNameContext:
     case DeclaratorContext::FunctionalCastContext:
+    case DeclaratorContext::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 DeclaratorContext::PrototypeContext:
     case DeclaratorContext::LambdaExprParameterContext:
+    case DeclaratorContext::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);
 
+  bool TransformRequiresExprRequirements(ArrayRef<Requirement *> Reqs,
+      llvm::SmallVectorImpl<Requirement *> &Transformed);
+  TypeRequirement *TransformTypeRequirement(TypeRequirement *Req);
+  ExprRequirement *TransformExprRequirement(ExprRequirement *Req);
+  NestedRequirement *TransformNestedRequirement(NestedRequirement *Req);
+
   /// 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 Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
                                                          ConceptNameInfo,
                                                          FoundDecl,
                                                          NamedConcept, 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);
   }
 
   /// Build a new Objective-C array literal.
if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
     return ExprError();
 
   return getDerived().RebuildConceptSpecializationExpr(
       E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
       E->getConceptNameInfo(), E->getFoundDecl(), 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()->getBeginLoc());
+
+  if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(),
+                                               E->getLocalParameters(),
+                                               /*ParamTypes=*/nullptr,
+                                               /*ParamInfos=*/nullptr,
+                                               TransParamTypes, &TransParams,
+                                               ExtParamInfos))
+    return ExprError();
+
+  for (ParmVarDecl *Param : TransParams)
+    Param->setDeclContext(Body);
+
+  SmallVector<Requirement *, 4> TransReqs;
+  if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
+                                                     TransReqs))
+    return ExprError();
+
+  for (Requirement *Req : TransReqs)
+    if (auto *ER = dyn_cast<ExprRequirement>(Req))
+      if (ER->getReturnTypeRequirement().isTypeConstraint())
+        ER->getReturnTypeRequirement()
+                .getTypeConstraintTemplateParameterList()->getParam(0)
+                ->setDeclContext(Body);
+
+  return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body,
+                                          TransParams, TransReqs,
+                                          E->getRBraceLoc());
+}
+
+template<typename Derived>
+bool TreeTransform<Derived>::TransformRequiresExprRequirements(
+    ArrayRef<Requirement *> Reqs,
+    SmallVectorImpl<Requirement *> &Transformed) {
+  for (Requirement *Req : Reqs) {
+    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);
+    else
+      TransReq = getDerived().TransformNestedRequirement(
+                     cast<NestedRequirement>(Req));
+    if (!TransReq)
+      return true;
+    Transformed.push_back(TransReq);
+  }
+  return false;
+}
+
+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.isTypeConstraint()) {
+    TemplateParameterList *OrigTPL =
+        RetReq.getTypeConstraintTemplateParameterList();
+    TemplateParameterList *TPL =
+        getDerived().TransformTemplateParameterList(OrigTPL);
+    if (!TPL)
+      return nullptr;
+    TransRetReq.emplace(getSema().Context, TPL);
+  }
+  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::OMPRequires:
   case Decl::OMPCapturedExpr:
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
   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());
 }
 
+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();
+      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);
   unsigned NumTemplateArgs = Record.readInt();
   E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
   E->TemplateKWLoc = Record.readSourceLocation();
   Record.readDeclarationNameInfo(E->ConceptName);
   E->FoundDecl = ReadDeclAs<NamedDecl>();
   E->NamedConcept = ReadDeclAs<ConceptDecl>();
   const ASTTemplateArgumentListInfo *ArgsAsWritten =
       Record.readASTTemplateArgumentListInfo();
   llvm::SmallVector<TemplateArgument, 4> Args;
   for (unsigned I = 0; I < NumTemplateArgs; ++I)
     Args.push_back(Record.readTemplateArgument());
   E->setTemplateArguments(ArgsAsWritten, Args);
-  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) {
-        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());
-    }
+  E->setSatisfaction(readConstraintSatisfaction(Record));
+}
+
+static Requirement::SubstitutionDiagnostic *
+readSubstitutionDiagnostic(ASTRecordReader &Record) {
+  std::string SubstitutedEntity = Record.readString();
+  SourceLocation DiagLoc = Record.readSourceLocation();
+  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: {
+              // type-constraint
+              TemplateParameterList *TPL = Record.readTemplateParameterList();
+              ConceptSpecializationExpr *CSE = nullptr;
+              if (Status >= ExprRequirement::SS_ConstraintsNotSatisfied)
+                CSE = cast<ConceptSpecializationExpr>(Record.readExpr());
+              if (CSE)
+                Req.emplace(Record.getContext(), TPL, 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()) {
+          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());
 }

     case EXPR_COYIELD:
       S = new (Context) CoyieldExpr(Empty);
       break;
 
     case EXPR_DEPENDENT_COAWAIT:
       S = new (Context) DependentCoawaitExpr(Empty);
       break;
 
-    case EXPR_CONCEPT_SPECIALIZATION:
+    case EXPR_CONCEPT_SPECIALIZATION: {
       unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
       S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
       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 -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// 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);
-  ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
-  Record.push_back(TemplateArgs.size());
-  Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());
-  Record.AddSourceLocation(E->getTemplateKWLoc());
-  Record.AddDeclarationNameInfo(E->getConceptNameInfo());
-  Record.AddDeclRef(E->getFoundDecl());
-  Record.AddDeclRef(E->getNamedConcept());
-  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
-  for (const TemplateArgument &Arg : TemplateArgs)
-    Record.AddTemplateArgument(Arg);
-  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);
+  ArrayRef<TemplateArgument> TemplateArgs = E->getTemplateArguments();
+  Record.push_back(TemplateArgs.size());
+  Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc());
+  Record.AddSourceLocation(E->getTemplateKWLoc());
+  Record.AddDeclarationNameInfo(E->getConceptNameInfo());
+  Record.AddDeclRef(E->getFoundDecl());
+  Record.AddDeclRef(E->getNamedConcept());
+  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
+  for (const TemplateArgument &Arg : TemplateArgs)
+    Record.AddTemplateArgument(Arg);
+  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.isTypeConstraint()) {
+          Record.push_back(2);
+          Record.AddTemplateParameterList(
+              RetReq.getTypeConstraintTemplateParameterList());
+          if (ExprReq->Status >= ExprRequirement::SS_ConstraintsNotSatisfied)
+            Record.AddStmt(
+                RetReq.Value.get<ExprRequirement::
+                                 ReturnTypeRequirement::
+                                 TypeConstraintRequirement *>()->second);
+        } 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->getEndLoc());
+
+  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: 'this' argument to member function 'foo' 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*>;
+
+#if 0 // TODO: Concepts re-enable when we have placeholders.
+
+template<typename T, typename U> requires requires (T t) { { t } -> const Same<U> auto*; } // 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> auto 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> auto**; } // 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 *]}}
+
+#endif
+
+// Substitution failure in type constraint
+
+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 type constraint
+
+template<int T>
+concept IsEven = (T % 2) == 0;
+
+template<typename T> requires requires (T t) { { t } -> IsEven; } // expected-error{{concept named in type constraint must be a type 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]}}
+
+#if 0 // TODO: Concepts: Reenable when we have placeholder constraints
+  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> auto 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]}}
+#endif
+
+  template<typename T>
+  void g(T t) noexcept(sizeof(T) == 1) {}
+
+  template<typename T> concept C5 =
+    requires(T x) {
+      {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}}
+    };
+
+  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{{requires clause differs 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{{requires clause differs 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{{requires clause differs 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{{requires clause differs 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;
+
+// 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{{requires clause differs 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{{requires clause differs 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{{requires clause differs in template redeclaration}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) } noexcept; } // expected-error{{requires clause differs in template redeclaration}}
+struct r6;
+template<typename T> requires requires { { sizeof(T) } -> C1; } // expected-error{{requires clause differs 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{{requires clause differs in template redeclaration}}
+struct r7;
+template<typename T> requires requires { { sizeof(T) } noexcept -> int; } // expected-error{{requires clause differs in template redeclaration}}
+struct r7;
+template<typename T> requires requires { { sizeof(T) } -> T; } // expected-error{{requires clause differs 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 {{previous template declaration is here}}
+struct r8;
+template<typename U> requires requires { { sizeof(U) }; } // expected-error{{requires clause differs in template redeclaration}}
+struct r8;
+#if 0 // TODO: Concepts: Re-enable once we have placeholder constraints
+template<typename T> requires requires { { sizeof(T) } -> C1 auto; } // expected-error{{requires clause differs in template redeclaration}}
+struct r8;
+#endif
+
+#if 0 // TODO: Concepts: Re-enable once we have placeholder constraints
+template<typename T> requires requires { { sizeof(T) } -> const volatile C1 auto; }
+struct r9;
+template<typename U> requires requires { { sizeof(U) } -> const volatile C1 auto; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> C1 auto const volatile; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> C1 auto volatile const; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> const C1 auto volatile; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> volatile C1 auto const; }
+struct r9;
+template<typename T> requires requires { { sizeof(T) } -> volatile C1 decltype(auto) const; }
+struct r9;
+#endif
+
+template<typename T, typename U>
+concept C2 = true;
+
+template<typename T> requires requires { { sizeof(T) } -> C2<T>; }
+struct r11;
+template<typename U> requires requires { { sizeof(U) } -> C2<U>; } // expected-note{{previous template declaration is here}}
+struct r11;
+template<typename T> requires requires { { sizeof(T) } -> C2<T*>; } // expected-error{{requires clause differs 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{{requires clause differs 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{{requires clause differs 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{{requires clause differs in template redeclaration}}
+struct r14;
+template<typename T> requires requires(T i, T *j, T &k) { requires true; } // expected-error{{requires clause differs 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{{requires clause differs in template redeclaration}}
+struct r15;
+template<typename T> requires requires(const int k) { requires sizeof(k) == 1; } // expected-error{{requires clause differs 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{{requires clause differs in template redeclaration}}
+struct r16;

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;
+  requires requires {
+    requires false;
+  };
+}
+struct r1 { };
+
+using r1i = r1<int>;
+// expected-error@-1 {{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@-1 {{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@-1 {{constraints not satisfied for class template 'r3' [with T = int]}}
+
+template<typename T>
+struct S { static const int s = T::value; };
+
+template<typename T> requires requires { T::value; S<T>::s; }
+// expected-note@-1 {{because 'T::value' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+struct r4 { };
+
+using r4i = r4<int>;
+// expected-error@-1 {{constraints not satisfied for class template 'r4' [with T = int]}}
 No newline at end of file

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@-1{{because 'a + b' would be invalid: invalid operands to binary expression ('A' and 'const A')}}
+// expected-note@-2{{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@-1{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}}
+// expected-note@-2{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}}
+// expected-note@-3{{because 'a.foo()' would be invalid: 'this' argument to member function 'foo' 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@-1{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}}
+// expected-note@-2{{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)>;
+
+template<class T> void f(T) = delete;
+template<class T> requires (sizeof(T) == 1) void f(T) { }
+
+template<typename T> requires requires(T t) { f(t); }
+// expected-note@-1{{because 'f(t)' would be invalid: call to deleted function 'f'}}
+struct r5 {};
+
+using r5i1 = r5<int>;
+// expected-error@-1 {{constraints not satisfied for class template 'r5' [with T = int]}}
+using r5i2 = r5<char>;
+
+// 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 *]}}
+}

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; }; // expected-note{{referenced member 'type' is declared here}}
+
+// 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@-1 {{because 'T::type' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+// expected-note@-2 {{because 'T::type' would be invalid: no type named 'type' in 'C'}}
+// expected-note@-3 {{because 'T::type' would be invalid: typename specifier refers to non-type member 'type' in 'D'}}
+// expected-note@-4 {{in instantiation of template class 'invalid<D>' requested here}}
+// expected-note@-5 {{in instantiation of requirement here}}
+// expected-note@-6 {{while substituting template arguments into constraint expression here}}
+// expected-note@-7 {{because 'T::type' would be invalid}}
+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]}}
+
+template<typename T> struct invalid { typename T::type x; };
+// expected-error@-1 {{typename specifier refers to non-type member 'type' in 'D'}}
+using r1i5 = r1<invalid<D>>;
+// expected-error@-1 {{constraints not satisfied for class template 'r1' [with T = invalid<D>]}}
+// expected-note@-2 {{while checking constraint satisfaction for template 'r1<invalid<D> >' required here}}
+
+// 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@-1{{because 'T::temp<int>' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+// expected-note@-2{{because 'T::temp<int>' would be invalid: no member named 'temp' in 'D'}}
+// expected-note@-3{{because 'T::temp<int>' would be invalid: template name refers to non-type template 'G::template 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@-1 {{because 'S<T>' would be invalid: no type named 'type' in 'std_example::has_inner}}
+  template<typename T> using Ref = T&; // expected-note{{because 'Ref<T>' would be invalid: cannot form a reference to 'void'}}
+  template<typename T> concept C1 =
+    requires {
+      typename T::inner;
+      // expected-note@-1 {{because 'T::inner' would be invalid: type 'int' cannot be used prior to '::' because it has no members}}
+      // expected-note@-2 {{because 'T::inner' would be invalid: no type named 'inner' in 'std_example::has_type'}}
+    };
+  template<typename T> concept C2 = requires { typename S<T>; };
+  template<typename T> concept C3 = requires { 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(C1<has_inner_and_type> && C2<has_inner_and_type> && C3<has_inner_and_type>);
+  template<C1 T> struct C1_check {};
+  // expected-note@-1 {{because 'int' does not satisfy 'C1'}}
+  // expected-note@-2 {{because 'std_example::has_type' does not satisfy 'C1'}}
+  template<C2 T> struct C2_check {};
+  // expected-note@-1 {{because 'std_example::has_inner' does not satisfy 'C2'}}
+  template<C3 T> struct C3_check {};
+  // expected-note@-1 {{because 'void' does not satisfy 'C3'}}
+  using c1 = C1_check<int>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = int]}}
+  using c2 = C1_check<has_type>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = std_example::has_type]}}
+  using c3 = C2_check<has_inner>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::has_inner]}}
+  using c4 = C3_check<void>; // expected-error{{constraints not satisfied for class template 'C3_check' [with T = void]}}
+}
 No newline at end of file

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

+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify
+
+bool r1 = requires () {};
+// expected-error@-1 {{a requires expression must contain at least one requirement}}
+
+bool r2 = requires { requires true; };
+
+bool r3 = requires (int a, ...) { requires true; };
+// expected-error@-1 {{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@-1 {{use of undeclared identifier 'd'}}
+
+bool r7 = requires (bool c) { c; (requires (int d) { c; d; }); d; } && decltype(c){} && decltype(d){};
+// expected-error@-1 2{{use of undeclared identifier 'd'}}
+// expected-error@-2 {{use of undeclared identifier 'c'}}
+
+bool r8 = requires (bool, int) { requires true; };
+
+bool r9 = requires (bool a, int a) { requires true; };
+// expected-error@-1 {{redefinition of parameter 'a'}}
+// expected-note@-2 {{previous declaration is here}}
+
+bool r10 = requires (struct new_struct { int x; } s) { requires true; };
+// expected-error@-1 {{'new_struct' cannot be defined in a parameter type}}
+
+bool r11 = requires (int x(1)) { requires true; };
+// expected-error@-1 {{expected parameter declarator}}
+// expected-error@-2 {{expected ')'}}
+// expected-note@-3 {{to match this '('}}
+
+bool r12 = requires (int x = 10) { requires true; };
+// expected-error@-1 {{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@-1 {{expected parameter declarator}}
+
+bool r16 = requires (auto x) { requires true; };
+// expected-error@-1 {{'auto' not allowed in requires expression parameter}}
+
+bool r17 = requires (auto [x, y]) { requires true; };
+// expected-error@-1 {{'auto' not allowed in requires expression parameter}}
+// expected-error@-2 {{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@-1 {{expected identifier or template-id in type requirement}}
+
+bool r22 = requires { typename s::~s; };
+// expected-error@-1 {{expected identifier or template-id in type requirement}}
+
+template<typename T>
+bool r23 = requires { typename identity<T>::temp<T>; };
+// expected-error@-1 {{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; // expected-error{{expected identifier or template-id in type requirement}}
+};
+
+bool r25 = requires { ; };
+// expected-error@-1 {{expected expression}}
+
+bool r26 = requires { {}; };
+// expected-error@-1 {{expected expression}}
+
+bool r27 = requires { { 0 } noexcept; };
+
+bool r28 = requires { { 0 } noexcept noexcept; };
+// expected-error@-1 {{expected '->' before expression type requirement}}
+
+bool r29 = requires { { 0 } noexcept int; };
+// expected-error@-1 {{expected '->' before expression type requirement}}
+
+template<typename T>
+concept C1 = true;
+
+#if 0 // TODO: Concepts: Re-enable once we have placeholder constraints
+bool r30 = requires { { 0 } noexcept -> const volatile C1 auto; };
+
+bool r31 = requires { { 0 } noexcept -> const C1 auto volatile; };
+
+bool r32 = requires { { 0 } noexcept -> C1 auto const volatile; };
+
+bool r33 = requires { { 0 } noexcept -> const volatile C1 auto const volatile; }; // expected-warning {{duplicate 'const' declaration specifier}} expected-warning {{duplicate 'volatile' declaration specifier}}
+#endif
+
+template<typename T>
+T i1 = 0;
+
+bool r34 = requires { { 0 } noexcept -> const volatile i1; };
+// expected-error@-1 {{unknown type name 'i1'}}
+
+bool r35 = requires { { 0 } noexcept -> const int; };
+
+bool r36 = requires { { 0 } noexcept -> const volatile decltype(i1<int>); };
+
+template<typename T, typename U>
+concept C2 = true;
+
+#if 0 // TODO: Concepts: Re-enable once we have placeholder constraints
+bool r37 = requires { { 0 } noexcept -> const volatile C2 auto; };
+// expected-error@-1 {{concept 'C2' requires more than 1 template argument; provide the remaining arguments explicitly to use it here}}
+
+bool r38 = requires { { 0 } noexcept -> const volatile C1<> auto; };
+
+bool r39 = requires { { 0 } noexcept -> const volatile C2<int> auto; };
+#endif
+
+bool r40 = requires { requires false, 1; };
+// expected-error@-1 {{expected ';' at end of requirement}}
+
+bool r41 = requires { 0 noexcept; };
+// expected-error@-1 {{'noexcept' can only be used in a compound requirements (with '{' '}' around the expression)}}
+
+bool r42 = requires { 0 int; };
+// expected-error@-1 {{unexpected int after expression. Did you intend to use a compound requirement? (with '{' '}' around the expression)}}
+
+bool r43 = requires { requires true };
+// expected-error@-1 {{expected ';' at end of requirement}}
+
+bool r44 = requires (bool b) { requires sizeof(b) == 1; };
+
+// TODO: Concepts: Enable once we have placeholder constraints.
+
+bool r45 = requires { { 0 } -> auto&&; };
+// expected-error@-1 {{'auto' not allowed in expression type requirement}}
+
+bool r46 = requires { { 0 } -> decltype(auto); };
+// expected-error@-1 {{'decltype(auto)' not allowed in expression type requirement}}
+
+bool r47 = requires { { 0 } -> const auto *; };
+// expected-error@-1 {{'auto' not allowed in expression type requirement}}
+
+void r48(bool b) requires requires { 1 } {}
+// expected-error@-1 {{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@-1 {{because 'false_v<requires (int t) { requires is_same_v<decltype(t), int>; }>' evaluated to false}}
+// expected-note@-2 {{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@-1 {{because 'false_v<requires (short ts, unsigned short ts) { requires (sizeof (ts) == 2) && (sizeof (ts) == 2); }>'}}
+// expected-note@-2 {{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@-1 {{because 'false_v<requires (short ts) { requires sizeof (ts) != 0; } && requires (unsigned short ts) { requires sizeof (ts) != 0; }>' evaluated to false}}
+// expected-note@-2 {{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@-1 {{because 'false_v<requires { typename contains_template<int>::temp<contains_template<int> >; }>' evaluated to false}}
+  // expected-note@-2 {{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@-1{{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@-1 {{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@-1 {{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@-1 {{because 'false_v<requires { sizeof(int); { sizeof(int) }; }>' evaluated to false}}
+  // expected-note@-2 {{because 'false_v<requires { <<error-expression>>; { sizeof(T) }; }>' 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@-1 {{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, typename U = int>
+  concept C1 = is_same_v<T, U>;
+
+  template<typename T> requires false_v<requires(T t) { { t } -> C1<T>; }>
+  // expected-note@-1 {{because 'false_v<requires (int t) { { t } -> C1<int>; }>' evaluated to false}}
+  // expected-note@-2 {{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]}}
+
+
+  // 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@-1 {{because 'false_v<requires { { sizeof(int) } noexcept -> int; } && requires { { sizeof(short) } noexcept -> int; }>' 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 { sizeof(Ts); } && ...)> // expected-note{{because 'false_v<requires { sizeof(int); } && requires { sizeof(short); }>' 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 { { 0 } noexcept -> Ts; } && ...)>
+  // expected-note@-1{{because 'false_v<requires { { 0 } noexcept -> int; } && requires { { 0 } noexcept -> unsigned int; } && requires { { 0 } noexcept -> long; }>' evaluated to false}}
+  struct r6 {};
+
+  using r6i = r6<int, unsigned int, long>; // expected-error{{constraints not satisfied for class template 'r6' [with Ts = <int, unsigned int, long>]}}
+
+  template<typename T, typename U>
+  concept C2 = true;
+
+  template<typename... Ts> requires
+  false_v<(requires { { 0 } noexcept -> C2<Ts>; } && ...)>
+  // expected-note@-1 {{because 'false_v<requires { { 0 } noexcept -> C2<int>; } && requires { { 0 } noexcept -> C2<unsigned int>; }>' evaluated to false}}
+  struct r7 {};
+
+  using r7i = r7<int, unsigned int>; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = <int, unsigned int>]}}
+
+  template<typename... Ts> requires
+  false_v<(requires { { sizeof(Ts) } noexcept -> const volatile Ts; } && ...)>
+  // expected-note@-1 {{because 'false_v<requires { { sizeof(int) } noexcept -> const volatile int; } && requires { { sizeof(unsigned int) } noexcept -> const volatile 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>]}}
+}
+
+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@-1 {{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@-1 {{because 'false_v<requires { requires sizeof(int) == 0; sizeof(Ts); } && requires { requires sizeof(short) == 0; sizeof(Ts); }>' 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@-1 {{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>]}}
+
+template<typename T> requires
+false_v<(requires(T t) { T{t}; })> // T{t} creates an "UnevaluatedList" context.
+// expected-note@-1 {{because 'false_v<(requires (int t) { int{t}; })>' evaluated to false}}
+struct r6 {};
+
+using r6i = r6<int>;
+// expected-error@-1 {{constraints not satisfied for class template 'r6' [with T = int]}}

tools/libclang/CIndex.cpp

CXCursor clang_getCursorDefinition(CXCursor C) {
   case Decl::OMPDeclareMapper:
   case Decl::OMPRequires:
   case Decl::ObjCTypeParam:
   case Decl::BuiltinTemplate:
   case Decl::PragmaComment:
   case Decl::PragmaDetectMismatch:
   case Decl::UsingPack:
   case Decl::Concept:
+  case Decl::RequiresExprBody:
     return C;
 
   // Declaration kinds that don't make any sense here, but are
   // nonetheless harmless.
   case Decl::Empty:
   case Decl::TranslationUnit:
   case Decl::ExternCContext:
     break;

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::CoawaitExprClass:
   case Stmt::ConceptSpecializationExprClass:
+  case Stmt::RequiresExprClass:
   case Stmt::DependentCoawaitExprClass:
   case Stmt::CoyieldExprClass:
   case Stmt::CXXBindTemporaryExprClass:
   case Stmt::CXXDefaultArgExprClass:
   case Stmt::CXXDefaultInitExprClass:
   case Stmt::CXXFoldExprClass:
   case Stmt::CXXStdInitializerListExprClass:
   case Stmt::CXXScalarValueInitExprClass: