[Concepts] Concept Specialization Expressions

[saar.raz]

Summary

Part of the P0734r0 Concepts implementation effort. Added Concept Specialization Expressions and tests thereof. Also added constraint expression type verification. This diff depends on D40381.

[changyu]

lib/AST/ExprCXX.cpp

1481

You have four spaces of indenting here.

lib/Parse/ParseExpr.cpp

225

Indenting.

[saar.raz]

• Fixed indentation problems

[saar.raz]

Previous updated diff mistakenly included D40381, fixed that.

[saar.raz]

Fixed indentations.

[faisalv]

lib/Parse/ParseExpr.cpp

223

Are you sure this only accepts logical-or-epxressions? Unlike Hubert's initial implementation here, this seems to parse any expression (i.e including unparenthesized commas and assignments)? What am I missing?

[saar.raz]

lib/Parse/ParseExpr.cpp

223

Mm.. Good point, I was under the false assumption that this was equivalent - I'll fix it back, thanks :)

[saar.raz]

Reverted to original constraint parsing code.

[saar.raz]

• Moved general concepts-related function into SemaConcept.cpp

[• Quuxplusone]

include/clang/Basic/DiagnosticSemaKinds.td

2404

Extra period . here

lib/Serialization/ASTReaderStmt.cpp

4053

Peanut gallery says: All the other cases look like

S = new (Context) FooExpr(Context, Empty);

or

S = new (Context) FooExpr::CreateEmpty(Context);

not

S = new (Context) FooExpr(Context);

Is the visual difference in this case significant?

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

12

"test/Parser/cxx-concept-declaration.cpp" has some syntax tests for "value-concepts" of the form template<bool x> concept.... Would it make sense to add some semantic tests for template<bool x> concept... in or near this test file?
(This could plausibly be "out of scope." I merely mention it.)

test/Parser/cxx-concept-declaration.cpp

36

Peanut gallery says: IIUC, C12<T> is satisfied whenever T has a constexpr constructor and a constexpr implicit conversion to bool that returns true? Or (because this is an atomic constraint and atomic constraints don't do conversions, as we can see on line 31 above) is C12<T> *actually* never satisfiable (but there's no diagnostic expected here because T{} is dependent)?

[saar.raz]

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

12

Good idea, I'll add some of those.

test/Parser/cxx-concept-declaration.cpp

36

C12 will only accept bool, and there's no diagnostic because it's dependent is correct.

[saar.raz]

• Addressed comments: Added semantic tests for value and template concepts, removed extra period and modified CSE ctor to fit in nicer.

[saar.raz]

• Fixed incorrect checking of atomic constraint types.

[faisalv]

include/clang/AST/ExprCXX.h

4416

Typo (Hubert): concepts -> concept

4419

Hubert: The concept named.

4420

NamedConcept

include/clang/Sema/Sema.h

5577

Hubert: clang-format this

5580

Hubert: Typo: emitted

lib/AST/ExprCXX.cpp

1441

Hubert: clang-format

1478

Hubert: This needs a TODO: the idea is not to drop SFINAE errors, but to avoid instantiation that may trigger errors not in the immediate context of instantiation. The substitution needs to happen piecewise.

1485

Hubert: The name of the function gives no indication that it modifies the expression node. The interface of the function extends past what is expected.

[saar.raz]

lib/AST/ExprCXX.cpp

1478

Could you elaborate/give an example where this handling is inappropriate?

[saar.raz]

Addressed most comments.

[saar.raz]

Applied missing clang-format.

[hubert.reinterpretcast]

lib/AST/ExprCXX.cpp

1478

Determining satisfaction requires normalization (lazy normalization should be considered).
The determination of satisfaction then proceeds by handling the left-hand side of conjunction and disjunction constraints before possibly substituting into the right-hand side; i.e., there is short-circuiting behaviour.

Example:

template <typename T>
concept C = true;

template <typename T>
struct Q { static constexpr T value = nullptr; };

template <typename T>
requires C<T> || T::value
struct A { };

template <typename T>
requires C<T> || Q<T>::value
struct B { };

A<int> a; // okay
B<int> b; // okay

[saar.raz]

lib/AST/ExprCXX.cpp

1478

OK I see your point. You said this should be a TODO - do you think this should be delayed to a further patch (namely D41569, where we actually deal with diagnostics and stuff)?
About lazy normalization, I tend to think it is not a good idea - you'll probably check satisfaction for every defined constraint expression at some point, and do that many more times than you'd define a new one

[hubert.reinterpretcast]

lib/AST/ExprCXX.cpp

1478

The status quo of this patch with regards to this topic is not quite something that I would like to commit onto trunk.

As for normalization: The process is needed for distinct purposes with somewhat differing output requirements.
The order-dependent form (to check for satisfaction) can be integrated with the substitution and evaluation: that is, the output of normalization is realized in control flow, and not "stored".

The order-independent form (to check for subsumption) could be delayed until overload resolution with a constrained candidate reaches the point where determining subsumption is necessary.

[saar.raz]

• Switched to piecewise substitution of atomic constraints when evaluating constraint expressions
• Added tests for piecewise substitution behavior
• Removed some redundant parentheses

[saar.raz]

• Switch to ASTTemplateArgumentListInfo, add ConstantEvaluated context when parsing constraints

[rsmith]

include/clang/AST/ExprCXX.h

4420

You should also track the FoundDecl and the optional NestedNameSpecifierLoc (just like a DeclRefExpr would). Clang-based tools (particularly refactoring tools) need those. There's also an optional template keyword, but it can never matter in practice because the nested name specifier can never be dependent, so it's probably not the most high-priority thing to track.

4423–4424

It'd be nice if at least one of these two arrays could be tail-allocated.

4459–4463

Passing Sema in here is a major layering violation. Here's how this should work:

• The AST code represents the AST model; its functions should generally not be able to fail.
• Sema checks the semantic constraints and enforces the validity of operations, and updates the AST node as appropriate

In this case, Sema should be checking the template argument list as written against the concept's parameter list, forming a resolved list of template arguments, and then passing both the as-written information and the resolved arguments to this AST node for storage.

4474–4481

Do you really need mutators for the 'satisfied' flag and the concept name location?

include/clang/Basic/DiagnosticSemaKinds.td

2405

Find a way to describe this problem without pretty-printing a substituted expression.

2407

Remove the '%0' here; you're already underlining it with a SourceRange (right?).

Please read http://clang.llvm.org/docs/InternalsManual.html#the-format-string and in particular "Take advantage of location information. The user will be able to see the line and location of the caret, so you don’t need to tell them that the problem is with the 4th argument to the function: just point to it."

2409

There's not really any such thing as a "concept specialization". Perhaps "while checking satisfaction of '%0'" or similar?

lib/AST/ExprCXX.cpp

1460

You will need to skip over a top-level ExprWithCleanups (I can't think off-hand of any other nodes that could show up here, but there might be more).

1552–1553

Build a CodeSynthesisContext for this rather than adding an ad-hoc note to the last diagnostic that happens to come from substitution (which might not be the error you care about, and might even be suppressed by warning flags).

lib/AST/ExprConstant.cpp

9085–9087

You don't need to check for this. If the evaluator is called on a value-dependent expression, that's a bug in the caller.

lib/AST/StmtPrinter.cpp

2553

You should print out the nested name specifier here. (And ideally also the template keyword, if specified...). And you should print the name of the found declaration, not the name of the concept (although they can't differ currently).

lib/Parse/ParseTemplate.cpp

374–377

Remove comment and braces. We don't need to say that an invalid ExprResult means a diagnostic was produced, because that's always implied by the ExprResult being invalid.

lib/Sema/SemaConcept.cpp

23

* on the right, please. And replace BinaryOperator with auto since it's initialized by a dyn_cast.

25–26

&& on the previous line, and align the two operands. (Or get clang-format to do it for you.)

35

What justifies rejecting this prior to any use of the concept that would result in a satisfaction check?

(I think checking this is a good thing; what I'm wondering is whether we need to file a core issue to get the wording updated to allow us to reject such bogus concepts even if they're never used.)

38–42

Call IgnoreParenImpCasts before checking the type of an atomic constraint, rather than adding an extra recursive step here.

116

Please fix :)

[rsmith]

lib/Sema/SemaExprCXX.cpp

7690 ↗

(On Diff #159234)

Please fix.

lib/Sema/TreeTransform.h

2943–2956

We need to convert the template arguments when rebuilding. This should call CheckConceptTemplateId instead. (After fixing that, please inline CreateConceptSpecializationExpr into its only caller.)

Please also add a test that checks we do convert the template arguments here.

[saar.raz]

@rsmith - thanks for the responses!
Will also address the comments I haven't responded to soon.

include/clang/AST/ExprCXX.h

4420

Isn't the FoundDecl just the NamedConcept?

4423–4424

Now that you mention it, TemplateArgs is never even used or set, I'll remove it.
As for TemplateArgInfo - do you mean allocate the ASTTemplateArgumentListInfo itself as a trailing obj or the individual TemplateArgumentLocs? the former seems more reasonable to me as it's convenient to have an ASTTemplateArgumentListInfo object around

4474–4481

They're here only because of ASTReader/Writer. I guess I can use a friend decl instead.

lib/AST/StmtPrinter.cpp

2553

Are there possible upcoming changes that'll make them differ?

lib/Sema/SemaConcept.cpp

35

I guess this is already justified, if awkwardly (NDR) by [temp.res]p8.2

[saar.raz]

lib/Sema/SemaConcept.cpp

35

Correction - it says that IFNDR occurs when no substitution would result in a valid expression, so maybe this is well formed after all.
In this case it is a valid expression but not a valid constraint expression, maybe that's the missing word here?

[saar.raz]

Address Richard's CR comments. Among other things:

• CSEs overhauled and now store both source and converted template arguments (latter are tail-allocated), template KW location and NNS.
• CSEs no longer violate layering - satisfaction check now moved back to CheckConceptTemplateId.
• CodeSynthesisContexts created for both the act of checking the associated constraints of a template or the constraint expression of a concept (non-SFINAE), and for the act of substituting template arguments into a(n atomic) constraint expression (SFINAE).
• Added more tests for cases where substitution leads to a non-SFINAE failure and emits diagnostics
• Fixed and added test for incorrect conversion of instantiated CSE argument list.

[saar.raz]

Removed unused "note_in_concept_specialization" diagnostic ID.

[• Quuxplusone]

include/clang/Sema/Sema.h

7134

Missing a trailing comma here.

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

121

Nit: You could use // expected-note@-1{{...}}, // expected-note@-2{{...}} to make lines like this more readable.

test/Parser/cxx-concept-declaration.cpp

48

Should you static-assert the expected results?

static_assert(!C12<bool>);
static_assert(C13<int>);
static_assert(C14<int>);
static_assert(C15<int>);
static_assert(C16<true>);
static_assert(C16<false>);
static_assert(C17<true>);
static_assert(!C17<false>);

[saar.raz]

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

121

😮😳 Well you learn something every day

test/Parser/cxx-concept-declaration.cpp

48

That's not the point of these tests but it couldn't hurt, I guess

[saar.raz]

Address Arthur's comments, add missing CorrectDelayedTyposInExpr

[steveire]

include/clang/AST/DeclTemplate.h

3063

getLocEnd is deprecated and will be removed soon. See http://clang-developers.42468.n3.nabble.com/API-Removal-Notice-4-weeks-getStartLoc-getLocStart-getLocEnd-td4061566.html

[saar.raz]

include/clang/AST/DeclTemplate.h

3063

Good to know, but I'm not yet merged against trunk so getEndLoc isn't here yet (will soon post a merged version of this patch)

[saar.raz]

• Fix bad ArgsAsWritten assertion, add missing null initializer in ConceptSpecializationExpr.

[rsmith]

include/clang/AST/ExprCXX.h

4420

Not in general, no. The FoundDecl could be a UsingShadowDecl.

lib/AST/ExprCXX.cpp

1472

This is incorrect. Whether the expression is dependent is not the same thing as whether it's instantiation-depnedent. A concept specialization should be considered instantiation-dependent if it has any instantiation-dependent template arguments, and should be considered value-dependent if it has any dependent template arguments.

For example, Concept<sizeof(sizeof(T))> has an instantiation-dependent template argument, but no dependent template arguments, so should be instantiation-dependent (the validity of the construct can depend on the type T) but not value-dependent (the value of the construct is always Concept<sizeof(size_t)>, which doesn't depend on T).

lib/AST/StmtPrinter.cpp

2553

p0945r0 would allow them to differ.

lib/Sema/SemaConcept.cpp

106–113

Please collect the notes from EvalutaeAsBooleanCondition and emit them here, so the user knows /why/ the expression was non-constant.

lib/Sema/SemaTemplate.cpp

3907–3911

Add braces around this for, because its body contains multiple statements. (Generally, if an inner construct has braces we want outer constructs to have them too.)

lib/Sema/SemaTemplateInstantiate.cpp

679–681

Is this note ever useful? It will presumably always point into the same concept definition that the prior diagnostic also pointed at, and doesn't seem to add anything in the testcases.

Maybe we could keep the CodeSynthesisContext around as a marker that we've entered a SFINAE context, but not have any corresponding diagnostic. (The note produced for the enclosing ConstraintsCheck context covers that.) Or we could remove this and store a flag on the ConstraintsCheck to indicate whether we're in a SFINAEable portion of it.

[saar.raz]

lib/Sema/SemaTemplateInstantiate.cpp

679–681

If the concept definition is multiline/contains macros, this would point at the exact place where the problematic constraint occured, we should probably add tests for this case though.
Maybe we can omit the diagnostic when the concept and the constraint are on the same line or something?

[saar.raz]

lib/Sema/SemaTemplateInstantiate.cpp

679–681

Correction - I just now realized you were referring to the 'in instantiation of template class' note and not the 'while checking the satisfaction...' note.
In this case - the only case I can think of where the problematic instantiation and the constraint expression would be in very different places is indeed multiline constraint expressions or macros in a constraint expression (but you know better than I do - can you think of any other cases? or maybe there are other non-SFINAE errors that can result from substitution and would not produce a note?). Maybe these cases are remote enough to warrant removing this diagnostic or as I said earlier omit them in cases where they are unhelpful.

[saar.raz]

• Address CR comments - add FoundDecl tracking, instantiationdependent calculation, display non-constant expression diagnostic notes

[saar.raz]

Moved from getLocStart, getLocEnd to getBeginLoc, getEndLoc. Rebase onto master/trunk.

[saar.raz]

Add new CodeSynthesisContexts to switch where they were missing

[saar.raz]

Fix wrong patch uploaded

[saar.raz]

Add support for CSE mangling

[saar.raz]

Delay support for mangling to later patch (where CSEs are formed instead of UnresolvedLookupExprs with dependent args)

[saar.raz]

Rebase onto trunk.

[rsmith]

include/clang/Sema/Sema.h

5904

(Nit: please align the second and subsequent parameters here with the first one.)

7487–7488

It'd be useful to note that this context covers the check that atomic constraints have type bool and can be constant-evaluated. (It's not obvious how we'd hit diagnostics in this case, since most substitution failures result in an unsatisfied constraint.)

lib/AST/ExprCXX.cpp

1703–1704

It'd be nice to assert that the nested name specifier is neither instantiation-dependent nor contains an unexpanded parameter pack. (That's true today because the NNS of a concept specialization expression can only refer to a namespace.) If the NNS could be instantiation-dependent or contain an unexpanded pack, we should inherit those properties here.

1708–1709

This code would be a little clearer if you moved an if (IsDependent && ContainsUnexpandedParameterPack && IsInstantiationDependent) check to the end of the loop. (I doubt the change will ever make any performance difference.)

lib/AST/StmtProfile.cpp

1303–1305

It seems a little inconsistent to use the named concept rather than the found decl (that is, resolved rather than as-written), but to use the as-written template arguments rather than the resolved and converted arguments. (I don't think it matters either way, since the profiler is in principle allowed to use either the as-written or resolved form, but generally it should prefer to use the as-written form.)

lib/Sema/SemaConcept.cpp

30

Nit: indent the second line so that the two CheckConstraintExpression calls line up.

35

OK, I'll take this to the core reflector to make sure the wording is clear this is ill-formed, no diagnostic required.

38–42

I think we're missing this, and we won't reject:

template<typename T> concept bool X = true && (0 && 0);

because we treat (0 && 0) as an atomic constraint rather than treating the two 0 subexpressions as atomic constraints here.

(Maybe add ConstraintExpression = ConstraintExpression->IgnoreParenImpCasts(); or something like that to the start of the function?)

52–69

If an operator&& or operator|| function is declared, this could be a CXXOperatorCallExpr instead. You will need to recurse into those constructs too.

70–72

Consider using IgnoreParenImpCasts here rather than manually handling these cases. (We should be consistent in the mechanism by which we traverse constraint expressions.)

This will do different things particularly for certain language extensions, such as _Generic, __builtin_choose_expr, and __extension (which are treated as being parens-like).

73–75

This case is not handled by CheckConstraintExpression; we should be consistent in whether we step over these or not.

Perhaps it would make sense to factor out a mechanism to take an expression and classify it as atomic constraint (with the corresponding expression), or conjunction (with a pair of subexpressions), or disjunction (with a pair of subexpressions), and use that everywhere we traverse a constraint expression.

lib/Sema/SemaTemplate.cpp

4256–4264

isSatisfied only looks at whether the expression is value-dependent; if it's instantiation-dependent but not value-dependent, then you won't have computed whether it's satisfied but will still permit access to that value. We should be checking whether the arguments are dependent here, not whether they're value-dependent. (And since you need to compute that here anyway, I think it'd make more sense to pass in an "is value-dependent" flag to ConstraintSpecializationExpr::Create.)

lib/Sema/SemaTemplateInstantiate.cpp

522

Please delete this empty else block (I assume this is left behind from prior changes).

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

8–11

These tests at least theoretically depend on the target; please add a -triple x86_64-linux-gnu or whatever to this file so that this test doesn't fail on targets where sizeof(int) is not 4. (I'm not sure we have any such targets right now, but it's not guaranteed.)

[saar.raz]

Address CR comments by rsmith

[saar.raz]

lib/Sema/SemaConcept.cpp

52–69

Atomic constraints will have bool types anyway, can this really happen?

73–75

Since this part will be changed in later patches, I'd like to delay this fix to a later patch for now.

lib/Sema/SemaTemplateInstantiate.cpp

679–681

In any case, I'm in favor of pushing this to a separate patch (after we have diagnostics for requires exprs, which would suffer from a similar problem)

[rsmith]

Only minor comments, let me know if you'd like me to take another look after addressing these, or just go ahead and commit. Thanks!

clang/lib/AST/ExprCXX.cpp

1676–1677 ↗

(On Diff #224789)

Consider passing IsSatisfied and IsValueDependent as a single Optional<bool> (with None meaning value-dependent).

1719–1720 ↗

(On Diff #224789)

Please add

assert((!isValueDependent() || isInstantiationDependent()) && "should not be value-dependent");

or similar. If we marked the expression as being value-dependent but it's not instantiation-dependent, things would go badly wrong later (we wouldn't substitute into it during instantiation, for example).

clang/lib/Sema/SemaConcept.cpp

39 ↗

(On Diff #224789)

No need for getNonReferenceType() here; expressions never have reference type.

40–41 ↗

(On Diff #224789)

I think it'd be a bit better to remove the getUnqualifiedType() call and use hasSameUnqualifiedType instead. That way the diagnostic below will preserve the cv-qualifications (along with any type sugar that you would need to remove to remove the qualifiers).

clang/lib/Serialization/ASTReaderStmt.cpp

737 ↗

(On Diff #224789)

Please can you add some basic test coverage for the serialization code?

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

1 ↗

(On Diff #224789)

Can we remove -fconcepts-ts from the RUN line?

include/clang/AST/DeclTemplate.h

     ConstraintExpr = CE;
   }
 
-  // TODO: Should do source range properly.
+
   SourceRange getSourceRange() const override LLVM_READONLY {
-    return SourceRange(getLocation(), getLocation());
+    return SourceRange(getLocation(), getConstraintExpr()->getLocEnd());
   }
 
   // Implement isa/cast/dyncast/etc.

include/clang/AST/ExprCXX.h

 #include "clang/AST/Decl.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/NestedNameSpecifier.h"

 class LambdaCapture;
 class NonTypeTemplateParmDecl;
 class TemplateParameterList;
+class Sema;
 
 //===--------------------------------------------------------------------===//
 // C++ Expressions.

   }
 };
 
+/// \brief Represents the specialization of a concept - evaluates to a prvalue
+/// of type bool.
+///
+/// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
+/// specialization of a concept results in a prvalue of type bool.
+class ConceptSpecializationExpr final : public Expr,
+      private llvm::TrailingObjects<ConceptSpecializationExpr,
+                                    TemplateArgument> {
+  friend class ASTStmtReader;
+  friend TrailingObjects;
+
+  // \brief The optional nested name specifier used when naming the concept.
+  NestedNameSpecifierLoc NestedNameSpec;
+
+  /// \brief The location of the template keyword, if specified when naming the
+  /// concept.
+  SourceLocation TemplateKWLoc;
+
+  /// \brief The location of the concept name in the expression.
+  SourceLocation ConceptNameLoc;
+
+  /// \brief The concept named, and whether or not the concept with the given
+  /// arguments was satisfied when the expression was created.
+  /// If any of the template arguments are dependent (this expr would then be
+  /// isValueDependent()), this bit is to be ignored.
+  llvm::PointerIntPair<ConceptDecl *, 1, bool> NamedConcept;
+
+  /// \brief The template argument list source info used to specialize the
+  /// concept.
+  const ASTTemplateArgumentListInfo *ArgsAsWritten;
+
+  /// \brief The number of template arguments in the tail-allocated list of
+  /// converted template arguments.
+  unsigned NumTemplateArgs;
+
+  ConceptSpecializationExpr(ASTContext &C, NestedNameSpecifierLoc NNS,
+                            SourceLocation TemplateKWLoc,
+                            SourceLocation ConceptNameLoc,
+                            ConceptDecl *CD,
+                            const ASTTemplateArgumentListInfo *ArgsAsWritten,
+                            ArrayRef<TemplateArgument> ConvertedArgs,
+                            bool IsSatisfied);
+
+  ConceptSpecializationExpr(EmptyShell Empty, unsigned NumTemplateArgs);
+
+public:
+
+  static ConceptSpecializationExpr *
+  Create(ASTContext &C, NestedNameSpecifierLoc NNS,
+         SourceLocation TemplateKWLoc, SourceLocation ConceptNameLoc,
+         ConceptDecl *CD, const ASTTemplateArgumentListInfo *ArgsAsWritten,
+         ArrayRef<TemplateArgument> ConvertedArgs, bool IsSatisfied);
+
+  static ConceptSpecializationExpr *
+  Create(ASTContext &C, EmptyShell Empty, unsigned NumTemplateArgs);
+
+  const NestedNameSpecifierLoc &getNestedNameSpecifierLoc() const {
+    return NestedNameSpec;
+  }
+
+  ConceptDecl *getNamedConcept() const {
+    return NamedConcept.getPointer();
+  }
+
+  ArrayRef<TemplateArgument> getTemplateArguments() const {
+    return ArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(),
+                                      NumTemplateArgs);
+  }
+
+  const ASTTemplateArgumentListInfo *getTemplateArgsAsWritten() const {
+    return ArgsAsWritten;
+  }
+
+  /// \brief Set new template arguments for this concept specialization.
+  void setTemplateArguments(const ASTTemplateArgumentListInfo *ArgsAsWritten,
+                            ArrayRef<TemplateArgument> Converted);
+
+  /// \brief Whether or not the concept with the given arguments was satisfied
+  /// when the expression was created. This method assumes that the expression
+  /// is not dependent!
+  bool isSatisfied() const {
+    assert(!isValueDependent()
+           && "isSatisfied called on a dependent ConceptSpecializationExpr");
+    return NamedConcept.getInt();
+  }
+
+  SourceLocation getConceptNameLoc() const { return ConceptNameLoc; }
+
+  SourceLocation getTemplateKWLoc() const { return TemplateKWLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == ConceptSpecializationExprClass;
+  }
+
+  SourceLocation getLocStart() const LLVM_READONLY { return ConceptNameLoc; }
+  SourceLocation getLocEnd() const LLVM_READONLY {
+    return ArgsAsWritten->RAngleLoc;
+  }
+
+  // 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_STMT(ConceptSpecializationExpr, {
+  TRY_TO(TraverseTemplateArgumentLocsHelper(
+          S->getTemplateArgsAsWritten()->getTemplateArgs(),
+          S->getTemplateArgsAsWritten()->NumTemplateArgs));
+})
+
 // These literals (all of them) do not need any action.
 DEF_TRAVERSE_STMT(IntegerLiteral, {})
 DEF_TRAVERSE_STMT(CharacterLiteral, {})

include/clang/Basic/DiagnosticSemaKinds.td

 def err_concept_specialized : Error<
   "%select{function|variable}0 concept cannot be "
   "%select{explicitly instantiated|explicitly specialized|partially specialized}1">;
-def err_concept_initialized_with_non_bool_type : Error<
-  "constraint expression must be 'bool' but found %0">;
 def err_concept_decls_may_only_appear_in_global_namespace_scope : Error<
   "concept declarations may only appear in global or namespace scope">;
 def err_concept_extra_headers : Error<
   "extraneous template parameter list in concept definition">;
 def err_concept_no_associated_constraints : Error<
   "concept may not have associated constraints">;
+def err_non_constant_constraint_expression : Error<
+  "substitution into constraint expression resulted in a non-constant "
+  "expression">;
+def err_non_bool_atomic_constraint : Error<
+  "atomic constraint must be of type 'bool' (found %0)">;
+def note_in_concept_specialization : Note<
+  "in concept specialization '%0'">;
 
 def err_template_different_associated_constraints : Error<
   "associated constraints differ in template redeclaration">;

   " 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_constraint_substitution_here : Note<
+  "while substituting template arguments into constraint expression here">;
 def note_instantiation_contexts_suppressed : Note<
   "(skipping %0 context%s0 in backtrace; use -ftemplate-backtrace-limit=0 to "
   "see all)">;

include/clang/Basic/StmtNodes.td

 def DependentCoawaitExpr : DStmt<Expr>;
 def CoyieldExpr : DStmt<CoroutineSuspendExpr>;
 
+// C++2a Concepts expressions
+def ConceptSpecializationExpr : DStmt<Expr>;
+
 // Obj-C Expressions.
 def ObjCStringLiteral : DStmt<Expr>;
 def ObjCBoxedExpr : DStmt<Expr>;

include/clang/Sema/Sema.h

                                            CXXConversionDecl *Conv,
                                            Expr *Src);
 
-  // ParseObjCStringLiteral - Parse Objective-C string literals.
+  /// Check whether the given expression is a valid constraint expression.
+  /// A diagnostic is emitted if it is not, and false is returned.
+  bool CheckConstraintExpression(Expr *CE);
+
+  bool CalculateConstraintSatisfaction(ConceptDecl *NamedConcept,
+                                         MultiLevelTemplateArgumentList &MLTAL,
+                                         Expr *ConstraintExpr,
+                                         bool &IsSatisfied);
+
+    // ParseObjCStringLiteral - Parse Objective-C string literals.
   ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
                                     ArrayRef<Expr *> Strings);
 

 
   ExprResult
   CheckConceptTemplateId(const CXXScopeSpec &SS,
-                         const DeclarationNameInfo &NameInfo,
-                         ConceptDecl *Template,
-                         SourceLocation TemplateLoc,
+                         SourceLocation TemplateKWLoc,
+                         SourceLocation ConceptNameLoc,
+                         ConceptDecl *NamedConcept,
                          const TemplateArgumentListInfo *TemplateArgs);
 
   ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,

       /// We are defining a synthesized function (such as a defaulted special
       /// member).
       DefiningSynthesizedFunction,
+
+      // We are checking the constraints associated with a constrained entity or
+      // the constraint expression of a concept.
+      ConstraintsCheck,
+
+      // We are substituting template arguments into a constraint expression.
+      ConstraintSubstitution
     } Kind;
 
     /// \brief Was the enclosing context a non-instantiation SFINAE context?

                           ArrayRef<TemplateArgument> TemplateArgs,
                           SourceRange InstantiationRange);
 
+    struct ConstraintsCheck {};
+    /// \brief Note that we are checking the constraints associated with some
+    /// constrained entity (a concept declaration or a template with associated
+    /// constraints).
+    InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
+                          ConstraintsCheck, TemplateDecl *Template,
+                          ArrayRef<TemplateArgument> TemplateArgs,
+                          SourceRange InstantiationRange);
+
+    struct ConstraintSubstitution {};
+    /// \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, TemplateDecl *Template,
+                          sema::TemplateDeductionInfo &DeductionInfo,
+                          SourceRange InstantiationRange);
 
     /// \brief Note that we have finished instantiating this template.
     void Clear();

include/clang/Serialization/ASTBitCodes.h

       EXPR_FUNCTION_PARM_PACK,    // FunctionParmPackExpr
       EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr
       EXPR_CXX_FOLD,              // CXXFoldExpr
+      EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr
 
       // CUDA
       EXPR_CUDA_KERNEL_CALL,       // CUDAKernelCallExpr      

lib/AST/Expr.cpp

   case ObjCAvailabilityCheckExprClass:
   case CXXUuidofExprClass:
   case OpaqueValueExprClass:
+  case ConceptSpecializationExprClass:
     // These never have a side-effect.
     return false;
 

lib/AST/ExprCXX.cpp

 #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 "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"

 }
 
 void ArrayTypeTraitExpr::anchor() {}
+
+ConceptSpecializationExpr::ConceptSpecializationExpr(ASTContext &C,
+    NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
+    SourceLocation ConceptNameLoc, ConceptDecl *CD,
+    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    ArrayRef<TemplateArgument> ConvertedArgs, bool IsSatisfied)
+    : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_RValue, OK_Ordinary,
+           /*TypeDependent=*/false,
+           // All the flags below are set in setTemplateArguments.
+           /*ValueDependent=*/false, /*InstantiationDependent=*/false,
+           /*ContainsUnexpandedParameterPacks=*/false),
+      NestedNameSpec(NNS), TemplateKWLoc(TemplateKWLoc),
+      ConceptNameLoc(ConceptNameLoc), NamedConcept(CD, IsSatisfied),
+      NumTemplateArgs(ConvertedArgs.size()) {
+  setTemplateArguments(ArgsAsWritten, ConvertedArgs);
+}
+
+ConceptSpecializationExpr::ConceptSpecializationExpr(EmptyShell Empty,
+    unsigned NumTemplateArgs)
+    : Expr(ConceptSpecializationExprClass, Empty),
+      NumTemplateArgs(NumTemplateArgs) { }
+
+void ConceptSpecializationExpr::setTemplateArguments(
+    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    ArrayRef<TemplateArgument> Converted) {
+  assert(Converted.size() == NumTemplateArgs);
+  assert(!ArgsAsWritten && "setTemplateArguments can only be used once");
+  this->ArgsAsWritten = ArgsAsWritten;
+  std::uninitialized_copy(Converted.begin(), Converted.end(),
+                          getTrailingObjects<TemplateArgument>());
+  bool IsDependent = false;
+  bool ContainsUnexpandedParameterPack = false;
+  for (const TemplateArgumentLoc& LocInfo : ArgsAsWritten->arguments()) {
+    if (LocInfo.getArgument().isInstantiationDependent()) {
+      IsDependent = true;
+      if (ContainsUnexpandedParameterPack)
+        break;
+    }
+    if (LocInfo.getArgument().containsUnexpandedParameterPack()) {
+      ContainsUnexpandedParameterPack = true;
+      if (IsDependent)
+        break;
+    }
+  }
+  setValueDependent(IsDependent);
+  setInstantiationDependent(IsDependent);
+  setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack);
+}
+
+ConceptSpecializationExpr *
+ConceptSpecializationExpr::Create(ASTContext &C, NestedNameSpecifierLoc NNS,
+                                  SourceLocation TemplateKWLoc,
+                                  SourceLocation ConceptNameLoc,
+                                  ConceptDecl *CD,
+                               const ASTTemplateArgumentListInfo *ArgsAsWritten,
+                                  ArrayRef<TemplateArgument> ConvertedArgs,
+                                  bool IsSatisfied) {
+  void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
+                                ConvertedArgs.size()));
+  return new (Buffer) ConceptSpecializationExpr(C, NNS, TemplateKWLoc,
+                                                ConceptNameLoc, CD,
+                                                ArgsAsWritten, ConvertedArgs,
+                                                IsSatisfied);
+}
+
+ConceptSpecializationExpr *
+ConceptSpecializationExpr::Create(ASTContext &C, EmptyShell Empty,
+                                  unsigned NumTemplateArgs) {
+  void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
+                                NumTemplateArgs));
+  return new (Buffer) ConceptSpecializationExpr(Empty, NumTemplateArgs);
+}
 No newline at end of file

lib/AST/ExprClassification.cpp

   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
+  case Expr::ConceptSpecializationExprClass:
     return Cl::CL_PRValue;
 
     // Next come the complicated cases.

lib/AST/ExprConstant.cpp

   bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
   bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
 
+  bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
   // FIXME: Missing: array subscript of vector, member of vector
 };
 } // end anonymous namespace

   return Success(E->getValue(), E);
 }
 
+bool IntExprEvaluator::VisitConceptSpecializationExpr(
+       const ConceptSpecializationExpr *E) {
+  return Success(E->isSatisfied(), E);
+}
+
+
 //===----------------------------------------------------------------------===//
 // Float Evaluation
 //===----------------------------------------------------------------------===//

   case Expr::CXXBoolLiteralExprClass:
   case Expr::CXXScalarValueInitExprClass:
   case Expr::TypeTraitExprClass:
+  case Expr::ConceptSpecializationExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::CXXNoexceptExprClass:

lib/AST/ItaniumMangle.cpp

   case Expr::ConvertVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::TypeTraitExprClass:
+  case Expr::ConceptSpecializationExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:

lib/AST/StmtPrinter.cpp

   OS << ")";
 }
 
+void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
+  NestedNameSpecifierLoc NNS = E->getNestedNameSpecifierLoc();
+  if (NNS)
+    NNS.getNestedNameSpecifier()->print(OS, Policy);
+  if (E->getTemplateKWLoc().isValid())
+    OS << "template ";
+  OS << E->getNamedConcept()->getName();
+  printTemplateArgumentList(OS, E->getTemplateArgsAsWritten()->arguments(),
+                            Policy);
+}
+
 // C++ Coroutines TS
 
 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {

lib/AST/StmtProfile.cpp

   ID.AddInteger(S->getOp());
 }
 
+void StmtProfiler::VisitConceptSpecializationExpr(
+                                           const ConceptSpecializationExpr *S) {
+  VisitExpr(S);
+  VisitDecl(S->getNamedConcept());
+  VisitTemplateArguments(S->getTemplateArgsAsWritten()->getTemplateArgs(),
+                         S->getTemplateArgsAsWritten()->NumTemplateArgs);
+}
+
 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
                                           UnaryOperatorKind &UnaryOp,
                                           BinaryOperatorKind &BinaryOp) {

lib/CodeGen/CGExprScalar.cpp

     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
   }
 
+  Value *VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
+    return Builder.getInt1(E->isSatisfied());
+  }
+
   Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
     return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
   }

lib/Parse/ParseExpr.cpp

 /// \brief Parse a constraint-expression.
 ///
 /// \verbatim
-///       constraint-expression: [Concepts TS temp.constr.decl p1]
+///       constraint-expression: C++2a[temp.constr.decl]p1
 ///         logical-or-expression
 /// \endverbatim
 ExprResult Parser::ParseConstraintExpression() {
-  // FIXME: this may erroneously consume a function-body as the braced
-  // initializer list of a compound literal
-  //
-  // FIXME: this may erroneously consume a parenthesized rvalue reference
-  // declarator as a parenthesized address-of-label expression
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      Actions, Sema::ExpressionEvaluationContext::ConstantEvaluated);
   ExprResult LHS(ParseCastExpression(/*isUnaryExpression=*/false));
   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr));
-
+  if (Res.isUsable() && !Actions.CheckConstraintExpression(Res.get()))
+    return ExprError();
   return Res;
 }
 

lib/Parse/ParseTemplate.cpp

   }
 
   ExprResult ConstraintExprResult = ParseConstraintExpression();
-  if (ConstraintExprResult.isInvalid()) {
-    Diag(Tok.getLocation(), diag::err_expected_expression)
-      << "constraint-expression";
+  if (ConstraintExprResult.isInvalid())
     return nullptr;
-  }
 
   ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
   Expr *ConstraintExpr = ConstraintExprResult.get();

lib/Sema/CMakeLists.txt

   SemaCast.cpp
   SemaChecking.cpp
   SemaCodeComplete.cpp
+  SemaConcept.cpp
   SemaConsumer.cpp
   SemaCoroutine.cpp
   SemaCUDA.cpp

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/SemaDiagnostic.h"
+#include "clang/Sema/TemplateDeduction.h"
+#include "clang/Sema/Template.h"
+#include "clang/AST/ExprCXX.h"
+using namespace clang;
+using namespace sema;
+
+bool Sema::CheckConstraintExpression(Expr *ConstraintExpression) {
+  // C++2a [temp.constr.atomic]p1
+  // ..E shall be a constant expression of type bool.
+
+  if (auto *BinOp = dyn_cast<BinaryOperator>(ConstraintExpression))
+    if (BinOp->getOpcode() == BO_LAnd || BinOp->getOpcode() == BO_LOr)
+      return CheckConstraintExpression(BinOp->getLHS()) &&
+          CheckConstraintExpression(BinOp->getRHS());
+
+  // An atomic constraint!
+  if (ConstraintExpression->isTypeDependent())
+    return true;
+
+  QualType Type = ConstraintExpression->IgnoreParenImpCasts()->getType()
+                      .getNonReferenceType().getUnqualifiedType();
+  if (!Context.hasSameType(Type, Context.BoolTy)) {
+    Diag(ConstraintExpression->getExprLoc(),
+         diag::err_non_bool_atomic_constraint) << Type
+        << ConstraintExpression->getSourceRange();
+    return false;
+  }
+  return true;
+}
+
+bool
+Sema::CalculateConstraintSatisfaction(ConceptDecl *NamedConcept,
+                                      MultiLevelTemplateArgumentList &MLTAL,
+                                      Expr *ConstraintExpr,
+                                      bool &IsSatisfied) {
+  if (auto *BO = dyn_cast<BinaryOperator>(ConstraintExpr)) {
+    if (BO->getOpcode() == BO_LAnd) {
+      if (CalculateConstraintSatisfaction(NamedConcept, MLTAL, BO->getLHS(),
+                                          IsSatisfied))
+        return true;
+      if (!IsSatisfied)
+        return false;
+      return CalculateConstraintSatisfaction(NamedConcept, MLTAL, BO->getRHS(),
+                                             IsSatisfied);
+    } else if (BO->getOpcode() == BO_LOr) {
+      if (CalculateConstraintSatisfaction(NamedConcept, MLTAL, BO->getLHS(),
+                                          IsSatisfied))
+        return true;
+      if (IsSatisfied)
+        return false;
+      return CalculateConstraintSatisfaction(NamedConcept, MLTAL, BO->getRHS(),
+                                             IsSatisfied);
+    }
+  } else if (auto *PO = dyn_cast<ParenExpr>(ConstraintExpr))
+    return CalculateConstraintSatisfaction(NamedConcept, MLTAL,
+                                           PO->getSubExpr(), IsSatisfied);
+  else if (auto *C = dyn_cast<ExprWithCleanups>(ConstraintExpr))
+    return CalculateConstraintSatisfaction(NamedConcept, MLTAL, C->getSubExpr(),
+                                           IsSatisfied);
+
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      *this, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+
+  // Atomic constraint - substitute arguments and check satisfaction.
+  ExprResult E;
+  {
+    TemplateDeductionInfo Info(ConstraintExpr->getLocStart());
+    InstantiatingTemplate Inst(*this, ConstraintExpr->getLocStart(),
+                               InstantiatingTemplate::ConstraintSubstitution{},
+                               NamedConcept, Info,
+                               ConstraintExpr->getSourceRange());
+    if (Inst.isInvalid())
+      return true;
+    // We do not want error diagnostics escaping here.
+    Sema::SFINAETrap Trap(*this);
+
+    E = SubstExpr(ConstraintExpr, MLTAL);
+    if (E.isInvalid() || Trap.hasErrorOccurred()) {
+      // C++2a [temp.constr.atomic]p1
+      //   ...If substitution results in an invalid type or expression, the
+      //   constraint is not satisfied.
+      IsSatisfied = false;
+      return false;
+    }
+  }
+
+  if (!CheckConstraintExpression(E.get()))
+    return true;
+
+  if (!E.get()->EvaluateAsBooleanCondition(IsSatisfied, Context)) {
+      // C++2a [temp.constr.atomic]p1
+      //   ...E shall be a constant expression of type bool.
+    Diag(E.get()->getLocStart(),
+         diag::err_non_constant_constraint_expression)
+        << E.get()->getSourceRange();
+    return true;
+  }
+
+  return false;
+}

lib/Sema/SemaExceptionSpec.cpp

   case Expr::PredefinedExprClass:
   case Expr::SizeOfPackExprClass:
   case Expr::StringLiteralClass:
+  case Expr::ConceptSpecializationExprClass:
     // These expressions can never throw.
     return CT_Cannot;
 

lib/Sema/SemaTemplate.cpp

 
 ExprResult
 Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
-                             const DeclarationNameInfo &NameInfo,
-                             ConceptDecl *Template,
-                             SourceLocation TemplateLoc,
+                             SourceLocation TemplateKWLoc,
+                             SourceLocation ConceptNameLoc,
+                             ConceptDecl *NamedConcept,
                              const TemplateArgumentListInfo *TemplateArgs) {
-  // TODO: Do more stuff here, caller expects constraint
-  // expression to be returned. Works for non-dependent bool
-  // constraint expressions right now.
-  return Template->getConstraintExpr();
+  assert(NamedConcept && "A concept template id without a template?");
+
+  llvm::SmallVector<TemplateArgument, 4> Converted;
+  if (CheckTemplateArgumentList(NamedConcept, NamedConcept->getLocStart(),
+                           const_cast<TemplateArgumentListInfo&>(*TemplateArgs),
+                                /*PartialTemplateArgs=*/false, Converted,
+                                /*UpdateArgsWithConversion=*/false))
+    return ExprError();
+
+  bool IsSatisfied = true;
+  bool IsDependent = false;
+  for (TemplateArgument &Arg : Converted)
+    if (Arg.isInstantiationDependent()) {
+      IsDependent = true;
+      break;
+    }
+  if (!IsDependent) {
+    InstantiatingTemplate Inst(*this, ConceptNameLoc,
+        InstantiatingTemplate::ConstraintsCheck{}, NamedConcept, Converted,
+        SourceRange(SS.isSet() ? SS.getBeginLoc() : ConceptNameLoc,
+                    TemplateArgs->getRAngleLoc()));
+    MultiLevelTemplateArgumentList MLTAL;
+    MLTAL.addOuterTemplateArguments(Converted);
+    if (CalculateConstraintSatisfaction(NamedConcept, MLTAL,
+                                        NamedConcept->getConstraintExpr(),
+                                        IsSatisfied))
+      return ExprError();
+  }
+  return ConceptSpecializationExpr::Create(Context,
+      SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
+      TemplateKWLoc, ConceptNameLoc, NamedConcept,
+      ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs), Converted,
+      IsSatisfied);
 }
 
 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,

   }
 
   if (R.getAsSingle<ConceptDecl>() && !DependentArguments) {
-    return CheckConceptTemplateId(SS, R.getLookupNameInfo(),
+    return CheckConceptTemplateId(SS, TemplateKWLoc,
+                                  R.getLookupNameInfo().getBeginLoc(),
                                   R.getAsSingle<ConceptDecl>(),
-                                  TemplateKWLoc, TemplateArgs);
+                                  TemplateArgs);
   }
 
   // We don't want lookup warnings at this point.

   if (!NewDecl)
     return nullptr;
 
-  if (!ConstraintExpr->isTypeDependent() &&
-      ConstraintExpr->getType() != Context.BoolTy) {
-    // C++2a [temp.constr.atomic]p3:
-    // E shall be a constant expression of type bool.
-    // TODO: Do this check for individual atomic constraints
-    // and not the constraint expression. Probably should do it in
-    // ParseConstraintExpression.
-    Diag(ConstraintExpr->getSourceRange().getBegin(),
-        diag::err_concept_initialized_with_non_bool_type)
-      << ConstraintExpr->getType();
-    NewDecl->setInvalidDecl();
-  }
-
   if (NewDecl->getAssociatedConstraints()) {
     // C++2a [temp.concept]p4:
     // A concept shall not have associated constraints.

lib/Sema/SemaTemplateInstantiate.cpp

   case ExplicitTemplateArgumentSubstitution:
   case DeducedTemplateArgumentSubstitution:
   case PriorTemplateArgumentSubstitution:
+  case ConstraintsCheck:
     return true;
 
   case DefaultTemplateArgumentChecking:
   case DeclaringSpecialMember:
   case DefiningSynthesizedFunction:
+  case ConstraintSubstitution:
     return false;
   }
 

           PointOfInstantiation, InstantiationRange, Param, Template,
           TemplateArgs) {}
 
+Sema::InstantiatingTemplate::InstantiatingTemplate(
+    Sema &SemaRef, SourceLocation PointOfInstantiation,
+    ConstraintsCheck, TemplateDecl *Template,
+    ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
+    : InstantiatingTemplate(
+          SemaRef, CodeSynthesisContext::ConstraintsCheck,
+          PointOfInstantiation, InstantiationRange, Template, nullptr,
+          TemplateArgs) {}
+
+Sema::InstantiatingTemplate::InstantiatingTemplate(
+    Sema &SemaRef, SourceLocation PointOfInstantiation,
+    ConstraintSubstitution, TemplateDecl *Template,
+    sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
+    : InstantiatingTemplate(
+          SemaRef, CodeSynthesisContext::ConstraintSubstitution,
+          PointOfInstantiation, InstantiationRange, Template, nullptr,
+          {}, &DeductionInfo) {}
+
 void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
   Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
   InNonInstantiationSFINAEContext = false;

         Diags.Report(Active->PointOfInstantiation,
                      diag::note_template_nsdmi_here)
             << FD << Active->InstantiationRange;
-      } else {
+      } else if (auto *AD = dyn_cast<TypeAliasTemplateDecl>(D)) {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_template_type_alias_instantiation_here)
-          << cast<TypeAliasTemplateDecl>(D)
+          << AD
           << Active->InstantiationRange;
+      } else {
       }
       break;
     }

         << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
       break;
 
-    case CodeSynthesisContext::DefiningSynthesizedFunction:
+    case CodeSynthesisContext::DefiningSynthesizedFunction: {
       // FIXME: For synthesized members other than special members, produce a note.
       auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
       auto CSM = MD ? getSpecialMember(MD) : CXXInvalid;

       }
       break;
     }
+    case CodeSynthesisContext::ConstraintsCheck:
+      if (auto *CD = dyn_cast<ConceptDecl>(Active->Entity)) {
+        SmallVector<char, 128> TemplateArgsStr;
+        llvm::raw_svector_ostream OS(TemplateArgsStr);
+        CD->printName(OS);
+        printTemplateArgumentList(OS, Active->template_arguments(),
+                                  getPrintingPolicy());
+        Diags.Report(Active->PointOfInstantiation,
+                     diag::note_concept_specialization_here)
+          << OS.str()
+          << Active->InstantiationRange;
+        break;
+      }
+      // TODO: Concepts - implement this for constrained templates and partial
+      // specializations.
+      llvm_unreachable("only concept constraints are supported right now");
+      break;
+    case CodeSynthesisContext::ConstraintSubstitution:
+      Diags.Report(Active->PointOfInstantiation,
+                   diag::note_constraint_substitution_here)
+          << Active->InstantiationRange;
+      break;
+    }
   }
 }
 

       // Fall through.
     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
     case CodeSynthesisContext::ExceptionSpecInstantiation:
+    case CodeSynthesisContext::ConstraintsCheck:
       // This is a template instantiation, so there is no SFINAE.
       return None;
 

 
     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
-      // We're either substitution explicitly-specified template arguments
-      // or deduced template arguments, so SFINAE applies.
+    case CodeSynthesisContext::ConstraintSubstitution:
+      // We're either substituting explicitly-specified template arguments
+      // or deduced template arguments or a constraint expression, so SFINAE
+      // applies.
       assert(Active->DeductionInfo && "Missing deduction info pointer");
       return Active->DeductionInfo;
 

lib/Sema/TreeTransform.h

                                   RParenLoc, Length, PartialArgs);
   }
 
-  /// \brief Build a new Objective-C boxed expression.
+  /// \brief Build a new concept specialization expression.
+  ///
+  /// By default, performs semantic analysis to build the new expression.
+  /// Subclasses may override this routine to provide different behavior.
+  ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
+      SourceLocation TemplateKWLoc, SourceLocation ConceptNameLoc,
+      ConceptDecl *NamedConcept, TemplateArgumentListInfo *TALI) {
+    CXXScopeSpec SS;
+    SS.Adopt(NNS);
+    ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
+                                                         ConceptNameLoc,
+                                                         NamedConcept, TALI);
+    if (Result.isInvalid())
+      return ExprError();
+    return Result;
+  }
+
+    /// \brief Build a new Objective-C boxed expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.

                                        E->getLocEnd());
 }
 
+template<typename Derived>
+ExprResult
+TreeTransform<Derived>::TransformConceptSpecializationExpr(
+                                                 ConceptSpecializationExpr *E) {
+  const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
+  TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
+  if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
+                                              Old->NumTemplateArgs, TransArgs))
+    return ExprError();
+
+  return getDerived().RebuildConceptSpecializationExpr(
+      E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
+      E->getConceptNameLoc(), E->getNamedConcept(), &TransArgs);
+}
+
+
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {

lib/Serialization/ASTReaderStmt.cpp

   E->setRParenLoc(ReadSourceLocation());
 }
 
+void ASTStmtReader::VisitConceptSpecializationExpr(
+        ConceptSpecializationExpr *E) {
+  VisitExpr(E);
+  unsigned NumTemplateArgs = Record.readInt();
+  E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
+  E->TemplateKWLoc = Record.readSourceLocation();
+  E->ConceptNameLoc = Record.readSourceLocation();
+  E->NamedConcept.setPointer(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);
+  E->NamedConcept.setInt(Record.readInt() == 1);
+}
+
 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   VisitExpr(E);
   E->setLHS(Record.readSubExpr());

       S = new (Context) DependentCoawaitExpr(Empty);
       break;
 
+    case EXPR_CONCEPT_SPECIALIZATION:
+      unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
+      S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
+      break;
     }
 
     // We hit a STMT_STOP, so we're done with this expression.

lib/Serialization/ASTWriterStmt.cpp

   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.AddSourceLocation(E->getConceptNameLoc());
+  Record.AddDeclRef(E->getNamedConcept());
+  Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten());
+  for (const TemplateArgument &Arg : TemplateArgs)
+    Record.AddTemplateArgument(Arg);
+  Record.push_back(E->isSatisfied());
+  Code = serialization::EXPR_CONCEPT_SPECIALIZATION;
+}
+
+
 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
   VisitStmt(S);
   // NumCaptures

lib/StaticAnalyzer/Core/ExprEngine.cpp

     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
+    case Stmt::ConceptSpecializationExprClass:
       // Fall through.
 
     // Cases we intentionally don't evaluate, since they don't need

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

 // RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
-// expected-no-diagnostics
 
-template<typename T> concept C = true;
+template<typename T> concept C1 = true;
+static_assert(C1<int>);
+
+template<typename T> concept C2 = sizeof(T) == 4;
+static_assert(C2<int>);
+static_assert(!C2<long long int>);
+static_assert(C2<char[4]>);
+static_assert(!C2<char[5]>);
+
+template<typename T> concept C3 = sizeof(*T{}) == 4;
+static_assert(C3<int*>);
+static_assert(!C3<long long int>);
+
+struct A {
+  static constexpr int add(int a, int b) {
+    return a + b;
+  }
+};
+struct B {
+  static int add(int a, int b) {
+    return a + b;
+  }
+};
+template<typename U>
+concept C4 = U::add(1, 2) == 3; // expected-error {{substitution into constraint expression resulted in a non-constant expression}}
+static_assert(C4<A>);
+static_assert(!C4<B>); // expected-note {{while checking the satisfaction of concept 'C4<B>' requested here}}
+
+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>;
+
+static_assert(Same<int, int>);
+static_assert(Same<int, decltype(1)>);
+static_assert(!Same<int, unsigned int>);
+static_assert(!Same<A, B>);
+static_assert(Same<A, A>);
+
+static_assert(Same<bool, decltype(C1<int>)>);
+static_assert(Same<bool, decltype(C2<int>)>);
+static_assert(Same<bool, decltype(C3<int*>)>);
+static_assert(Same<bool, decltype(C4<A>)>);
+
+template<typename T> concept C5 = T{}; // expected-error {{atomic constraint must be of type 'bool' (found 'int')}}
+constexpr bool x = C5<int>; // expected-note {{while checking the satisfaction of concept 'C5<int>' requested here}}
+
+template<int x>
+concept IsEven = (x % 2) == 0;
+
+static_assert(IsEven<20>);
+static_assert(!IsEven<11>);
+
+template<template<typename T> typename P>
+concept IsTypePredicate = is_same_v<decltype(P<bool>::value), const bool>
+                          && is_same_v<decltype(P<int>::value), const bool>
+                          && is_same_v<decltype(P<long long>::value), const bool>;
+
+template<typename T> struct T1 {};
+template<typename T> struct T2 { static constexpr bool value = sizeof(T) == 2; };
+
+static_assert(IsTypePredicate<T2>);
+static_assert(!IsTypePredicate<T1>);
+
+namespace piecewise_substitution {
+  template <typename T>
+  concept True = true;
+
+  template <typename T>
+  concept A = True<T> || T::value;
+
+  template <typename T>
+  concept B = (True<T> || T::value);
+
+  template <typename T>
+  concept C = !True<T> && T::value || true; // expected-warning {{'&&' within '||'}} expected-note {{place parentheses around the '&&' expression to silence this warning}}
+
+  template <typename T>
+  concept D = (!True<T> && T::value) || true;
+
+  template <typename T>
+  concept E = T::value || True<T>;
+
+  template <typename T>
+  concept F = (T::value || True<T>);
+
+  template <typename T>
+  concept G = T::value && !True<T> || true; // expected-warning {{'&&' within '||'}} expected-note {{place parentheses around the '&&' expression to silence this warning}}
+
+  template <typename T>
+  concept H = (T::value && !True<T>) || true;
+
+  template <typename T>
+  concept I = T::value;
+
+  static_assert(A<int>);
+  static_assert(B<int>);
   static_assert(C<int>);
+  static_assert(D<int>);
+  static_assert(E<int>);
+  static_assert(F<int>);
+  static_assert(G<int>);
+  static_assert(H<int>);
+  static_assert(!I<int>);
+}
+
+// Short ciruiting
+
+template<typename T> struct T3 { using type = typename T::type; }; // expected-error{{type 'char' cannot be used prior to '::' because it has no members}} expected-error{{type 'short' cannot be used prior to '::' because it has no members}}
+
+template<typename T>
+concept C6 = sizeof(T) == 1 && sizeof(typename T3<T>::type) == 1; // expected-note{{while substituting template arguments into constraint expression here}} expected-note{{in instantiation of template class 'T3<char>' requested here}}
+
+template<typename T>
+concept C7 = sizeof(T) == 1 || sizeof(typename T3<T>::type) == 1; // expected-note{{while substituting template arguments into constraint expression here}} expected-note{{in instantiation of template class 'T3<short>' requested here}}
+
+static_assert(!C6<short>);
+static_assert(!C6<char>); // expected-note{{while checking the satisfaction of concept 'C6<char>' requested here}}
+static_assert(C7<char>);
+static_assert(!C7<short>); // expected-note{{while checking the satisfaction of concept 'C7<short>' requested here}}
+
+// Make sure argument list is converted when instantiating a CSE.
+
+template<typename T, typename U = int>
+concept SameSize = sizeof(T) == sizeof(U);
+
+template<typename T>
+struct X { static constexpr bool a = SameSize<T>; };
+
+static_assert(X<unsigned>::a);
 No newline at end of file

test/Parser/cxx-concept-declaration.cpp

 
 template<concept T> concept D1 = true; // expected-error {{expected template parameter}}
 
-template<typename T> concept C2 = 0.f; // expected-error {{constraint expression must be 'bool'}}
-
 struct S1 {
   template<typename T> concept C1 = true; // expected-error {{concept declarations may only appear in global or namespace scope}}
 };

 
 // TODO: Add test to prevent explicit specialization, partial specialization
 // and explicit instantiation of concepts.
+
+template<bool x> concept C7 = 2; // expected-error {{atomic constraint must be of type 'bool' (found 'int')}}
+template<bool x> concept C8 = 2 && x; // expected-error {{atomic constraint must be of type 'bool' (found 'int')}}
+template<bool x> concept C9 = x || 2 || x; // expected-error {{atomic constraint must be of type 'bool' (found 'int')}}
+template<bool x> concept C10 = 8ull && x || x; // expected-error {{atomic constraint must be of type 'bool' (found 'unsigned long long')}}
+template<typename T> concept C11 = sizeof(T); // expected-error {{atomic constraint must be of type 'bool' (found 'unsigned long')}}
+template<typename T> concept C12 = T{};
+template<typename T> concept C13 = (bool&&)true;
+template<typename T> concept C14 = (const bool&)true;
+template<typename T> concept C15 = (const bool)true;
+
+template<typename T, T v>
+struct integral_constant { static constexpr T value = v; };
+
+template <bool c> concept C16 = integral_constant<bool, c>::value && true;
+template <bool c> concept C17 = integral_constant<bool, c>::value;
+
+bool a = C16<true>;
+bool b = C17<true>;

tools/libclang/CXCursor.cpp

   case Stmt::TypeTraitExprClass:
   case Stmt::CoroutineBodyStmtClass:
   case Stmt::CoawaitExprClass:
+  case Stmt::ConceptSpecializationExprClass:
   case Stmt::DependentCoawaitExprClass:
   case Stmt::CoreturnStmtClass:
   case Stmt::CoyieldExprClass: