Parse concept definition

[saar.raz]

Summary

Per p0734r0.

[changyu]

I should add that this depends on

https://reviews.llvm.org/D40380

[saar.raz]

Also add:
In ASTDumper

+    void VisitConceptTemplateDecl(const ConceptTemplateDecl *D);

Implementation:

void ASTDumper::VisitConceptTemplateDecl(const ConceptTemplateDecl *D) {
  dumpName(D);
  dumpTemplateParameters(D->getTemplateParameters());
  VisitExpr(D->getConstraintExpression());
}

Address the other issues I've mentioned in the inline comments and we're good! Great job :)

include/clang/AST/DeclTemplate.h

3031

Add CreateDeserialized.

3035

Add setConstraintExpr (for use when calling CreateDeserialized, see ASTDeclReader)

include/clang/Parse/Parser.h

2995

C++2a

lib/Parse/ParseTemplate.cpp

365

Add a check to ParseConstraintExpression that the type is either dependent or bool, and add an apropriate diagnostic.

if (!ConstraintExpr->isTypeDependent() && ConstraintExpr->getType() != Context.BoolTy) {
  Diag(Init->getSourceRange().getBegin(),
       diag::err_concept_initialized_with_non_bool_type) << Init->getType();
  Concept->setInvalidDecl();
  return;
}

lib/Sema/SemaTemplate.cpp

3177–3178

Add

|| isa<ConceptDecl>

4191

We're gonna want to check

!TemplateSpecializationType::anyDependentTemplateArguments(*TemplateArgs, InstantiationDependent)

here as well - so that we can instantiate a ConceptSpecializationExpr later when we have it (we're not gonna want to instantiate a ConceptSpecializationExpr with dependent arguments.

7871

Check that !DC->isFileContext() (Concepts may only be defined at namespace scope)

7873

I think it would be better to just check that TemplateParameterLists.size() != 1 - it can't happen in a valid situation anyway, you'd want a diagnostic there.

7875

Check that c->getAssociatedConstraints() == nullptr ([temp.concept]p4 A concept shall not have associated constraints).
Add a TODO to make a test for that once we have actual associated constraints.

lib/Sema/SemaTemplateInstantiateDecl.cpp

3364

Yes -

llvm_unreachable("Concept definitions cannot reside inside a template");

lib/Serialization/ASTReaderDecl.cpp

2080

Add here:

D->setConstraintExpression(Record.readExpr());

And in ASTDeclWriter, a method VisitConceptDecl:

void ASTDeclWriter::VisitConceptTemplateDecl(ConceptTemplateDecl *D) {
  VisitTemplateDecl(D);
  Record.AddStmt(D->getConstraintExpression());
  Code = serialization::DECL_CONCEPT;
}

And call it in the appropriate places.

3786

Add a case: DECL_CONCEPT, also create that enum member.

[Rakete1111]

lib/Parse/ParseTemplate.cpp

160–163

No braces here please.

167

No else needed here.

373

Do we really need ThisDecl?

lib/Sema/SemaTemplate.cpp

4191

No braces here please.

4193

clang-format please :)

7866

Did you run this through clang-format?

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

2

There is no -fconcepts-ts flag AFAIK. Also, why -fcxx-exceptions, it's not needed here. The -x c++ part too. It should also be -std=c++2a.

[saar.raz]

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

2

There is a -fconcepts-ts flag (clang -Xclang -fconcepts-ts), I believe now that there is no more Concepts TS the flag should be removed as well and all concepts-related code be put under C++2a ifs.

[hubert.reinterpretcast]

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

2

This was discussed with Richard, Faisal, and Aaron Ballman before. We would like to use -Xclang -fconcepts until there is enough of an implementation. When we are ready, then we switch to having it directly under C++2a. There is no reason why dealing with the option cannot be done as a separate patch, so I don't think we need to hold up this one for that work.

[saar.raz]

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

2

OK, wasn't aware this was discussed before.
I agree then, leave the -fconcepts-ts for now.

[hubert.reinterpretcast]

include/clang/Sema/Sema.h

6405

Indentation issue here too.

lib/Parse/ParseTemplate.cpp

52

C++2a Concepts

365

I think that would still need a TODO to instead walk the constraint expression for atomic constraints and diagnose those.

template <typename T>
concept C = 1 || T::value; // error

lib/Sema/SemaTemplate.cpp

4142

Add more comments here. It looks like this allows us to get id-expressions naming concepts defined with non-dependent bool constraint expressions to "work" for now?

test/Parser/cxx-concept-declaration.cpp

0

Should add tests to prevent redeclaring concept names as either a "normal" (e.g., variable) or tag name.
Also the reverse for redeclaring a tag name as a concept.

Should add tests to prevent multiple definitions of the same concept.
Should eventually add tests to prevent explicit specialization, partial specialization and explicit instantiation of concepts: while the restriction is syntactic in the wording, that does not necessarily translate directly to the implementation strategy. In any case, we may discover that we want a nicer message.

Should add tests to prevent defining concepts at class scope.

[changyu]

lib/Parse/ParseTemplate.cpp

365

I'm guessing you meant for this to be in class Sema so I added this to Sema::ActOnConceptDefinition. Also what is Init here?

365

Why is that an error? [temp.constr.normal] in p0734r0 seems to say it's valid?

lib/Sema/SemaTemplate.cpp

4142

That's pretty much it.

4191

I'm following the style of the surrounding code here. I can remove the braces if you insist though.

7866

No, when I run the file through clang-format (with no arguments except the file), it reformats the whole file. How should I be running clang-format?

[changyu]

include/clang/Sema/Sema.h

6405

That last line is 79 characters long.

[hubert.reinterpretcast]

include/clang/Sema/Sema.h

6405

clang-format is happy to give:

ExprResult
CheckConceptTemplateId(const CXXScopeSpec &SS,
                       const DeclarationNameInfo &NameInfo,
                       ConceptDecl *Template, SourceLocation TemplateLoc,
                       const TemplateArgumentListInfo *TemplateArgs);

I'm no fan of blindly using clang-format, but its output is sometimes useful.

lib/Parse/ParseTemplate.cpp

365

From N4700 subclause 17.4.1.2 [temp.constr.atomic] paragraph 3:
[ ... ], and E shall be a constant expression of type bool

A search of "bool" in P0734R0 seems to indicate that is also the basis for the diagnostic Saar is requesting.

Although that wording only applies clearly when determining the satisfaction of C<T> for some T, it would be good to catch it early. I believe that the particular case I presented falls under the "no valid specialization" wording in [temp.res].

I think there is a gap between the wording and the intent if overloaded binary logical operators, detectable without substitution, are not sufficiently wrong on the part of the user that a compiler may refuse to translate the program.

lib/Sema/SemaTemplate.cpp

7866

One workflow that works is to clang-format the base file, clang-format with your changes, grab a patch and then apply it to the original base file (probably needs some manual work).

[Rakete1111]

lib/Sema/SemaTemplate.cpp

7866

I always copy the code I want to format, then pipe it into clang-format, and the paste it back with some manual adjustments to indentation.

[saar.raz]

Do the requested clang-formatting as shown by hubert, other than that looks good to me :)

[changyu]

• Fixed indent issues.
• Moved TODO on boolean atomic constraints to ActOnConceptDefinition where we are currently checking for boolean constraint expression

[faisalv]

Thanks for working on this! :)

include/clang/AST/DeclTemplate.h

3043

why not just fix it now?

return SourceRange(getTemplateParameters()->getTemplateLoc(), ConstraintExpr->getLocEnd();

?

include/clang/AST/RecursiveASTVisitor.h

1756

Perhaps something along these lines?

DEF_TRAVERSE_DECL(ConceptDecl, {    

  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
  
  TRY_TO(TraverseStmt(D->getConstraintExpr()));
  // FIXME: Traverse all the concept specializations (one we implement forming template-ids with them).
})

include/clang/Sema/Sema.h

6407

Have you considered just deferring formation of concept template-ids to the next patch (especially since it might require introduction of another AST node ConceptSpecializationDecl. We could just focus on handling concept declarations/definitions in this one (and emit an unimplemented error if someone tries to form a template-id with a concept within BuildTemplateId etc.) - but perhaps consider making sure we handle name clashes/redeclarations with any other parsed names in the same namespace (within this patch)?

lib/AST/DeclBase.cpp

786

Pls consider just lumping this case with 'Binding/VarTemplate' (which by the way also includes a comment for why we have to add the ugly IDNS_Tag hack here (personally i think we should refactor this functionality, currently it seems split between this and SemaLookup.cpp:getIDNS and would benefit from some sort of well-designed cohesion - but that's another (low-priority) patch)

lib/CodeGen/CGDecl.cpp

110

You would need to add this to EmitTopLevelDecl too to handle global-namespace concept declarations.

lib/Parse/ParseTemplate.cpp

360

I think we should diagnose qualified-name errors here much more gracefully than we do.

i.e. template<class T> concept N::C = ...

• perhaps try and parse a scope-specifier, and if found emit a diagnostic such as concepts must be defined within their namespace ...

lib/Sema/SemaTemplate.cpp

4137

I don't think we want to just return the constraint expr? I think we would need to create another conceptspecializationDecl node and nest it within a DeclRefExpr? But once again, I think we should defer this to another patch - no?

4185

const bool, no?

7869

Rename L as NameLoc?

7883

Perhaps add a lookup check here? (or a fixme that we are deferring to the next patch), something along these *pseudo-code* lines:

LookupResult Previous(*this, DeclarationNameInfo(DeclarationName(Name),NameLoc), LookupOrdinaryName);
LookupName(Previous, S);
if (Previous.getRepresentativeDecl())    ... if the decl is a concept - give error regarding only one definition allowed in a TU, if a different kind of decl then declared w a different symbol type of error?

7890

Consider refactoring these checks on constraint expressions into a separate function checkConstraintExpression (that we can also call from other contexts such as requires-clauses and nested requires expressions)?

7912

Why not use 'PushOnScopeChains' onto the enclosing scope?
Something along these lines:

assert(S->isTemplateParamScope() && S->getParent() && 
 !S->getParent()->isTemplateParamScope() && "...");
PushOnScopeChains(NewDecl, S->getParent(),/*AddToContext*/true);

test/Parser/cxx-concept-declaration.cpp

0

Name this file starting with cxx2a- please.

[saar.raz]

lib/Sema/SemaTemplate.cpp

4137

This was meant as a placeholder. The next patch (D41217) replaces this function, I don't think it is that much of a big deal what happens here in this patch.

7890

I did that in the upcoming patches, no need to do it here as well.

[faisalv]

lib/Sema/SemaTemplate.cpp

4137

This: " I don't think it is that much of a big deal what happens here in this patch." I think is poor practice in an open source project when you're not sure when the next patch will land.

I think, when features are implemented incrementally - each patch should diagnose the yet to be implemented features - and error out as gracefully as possible. So for instance replacing the body of this function with an appropriate diagnostic (that is then removed in future patches) would be the better thing to do here.

7890

Once again - relying on a future patch (especially without a clear FIXME) to tweak the architectural/factorization issues that you have been made aware of (and especially those, such as this, that do not require too much effort), is not practice I would generally encourage.

So changyu, if you agree that these suggestions would improve the quality of the patch and leave clang in a more robust state (maintenance-wise or execution-wise), then please make the changes. If not, please share your thoughts as to why these suggestions would either not be an improvement or be inconsistent with the theme of this patch.

Thanks!

[changyu]

lib/Sema/SemaTemplate.cpp

7912

The condition

S->isTemplateParamScope()

fails in this case

template<concept T> concept D1 = true; // expected-error {{expected template parameter}}

ParseTemplateDeclarationOrSpecialization calls ParseTemplateParameters which eventually calls ParseNonTypeTemplateParameter. ParseNonTypeTemplateParameter prints the diag and fails but does not cause ParseTemplateParameters to fail (I'm not sure why). ParseTemplateDeclarationOrSpecialization proceeds to parse the concept definition, and we get this

/home/changyu/test.cpp:1:10: error: expected template parameter
template<concept T> concept D1 = true; // expected-error {{expected template parameter}}
         ^
clang: /home/changyu/git/llvm/tools/clang/lib/Sema/SemaTemplate.cpp:7747: clang::Decl* clang::Sema::ActOnConceptDefinition(clang::Scope*, clang::MultiTemplateParamsArg, clang::IdentifierInfo*, clang::SourceLocation, clang::Expr*): Assertion `S->isTemplateParamScope() && "Not in template param scope?"' failed.

What should we do?

[faisalv]

lib/Sema/SemaTemplate.cpp

7912

I think this occurs because our template parameter list is incorrectly perceived as empty - i.e. once the error occurs - to continue processing errors clang assumes this case is an explicit-specialization and replaces the template parameter scope with the outer scope. I think the thing to do here - which might also address the case where folks actually write 'template<> concept' is to actually check if template-parameter-list is empty - and emit a diagnostic about concepts can not be explicit specializations or some such ...

On a somewhat related note - i think the logic for signaling, handling and propagating failures of parsing the template parameter list might be a little broken (fixing which, might avoid triggering the assertion in template<concept> but not template<>). I might submit a patch to fix that error handling-issue separately - but either way I think we should handle the explicit-specialization error?

Thoughts?

[changyu]

lib/Sema/SemaTemplate.cpp

7890

I removed it here since Saar fixed it in his patch.

[faisalv]

I think this looks good enough to commit - do you have commit privileges - or do you need one of us to commit it for you?
thank you!

[changyu]

I don't have commit privilege. And also there's one more problem we might want to address first.

Thank you.

lib/Parse/ParseTemplate.cpp

180

There's one problem here.

​I added this if in attempt to catch the following case (but it's wrong)

	​template<> concept D1 = true;  // expected-error {{expected template parameter}}

The problem is I'm not sure how to differentiate between the above situation and the following

	​template<concept T> concept D1 = true; // expected-error {{expected template parameter}}

Both have an empty template parameter list​. The latter case has diagnostic printed by ParseNonTypeTemplateParameter while the former has not (so we try to catch it here).

What should we do?

[faisalv]

lib/Parse/ParseTemplate.cpp

180

I was thinking that we would just emit a (redundant in the case of a bad template parameter) message in Sema if the template-parameters are empty that explicit specializations are not allowed here. while it would be a little misleading in the invalid template parameter case - to fix this robustly would require some fine-tuning and correcting some of the handshaking/error-propagation between the parsing of the template parameters and the code that calls it, I think. I would vote for not holding up this patch for that, unless you feel strongly you'd like to fix that behavior - then we can try and work on that first?

Thoughts?

[changyu]

I moved some template param checks from Parser::ParseTemplateDeclarationOrSpecialization to Parser::ParseConceptDefinition and Sema::ActOnConceptDefinition.

lib/Parse/ParseTemplate.cpp

180

Sure, let's fix that in another patch. I added a note for this in cxx2a-concept-declaration.cpp.

[saar.raz]

lib/Parse/ParseTemplate.cpp

160–163

Perhaps add a LangOpts.ConceptsTS check here?

[saar.raz]

lib/Parse/ParseTemplate.cpp

376

We could accept 'bool' here to be nice to people coming in from the old Concepts TS version of these decls - and emit a proper warning.

[faisalv]

I discussed this briefly w Hubert - and i'm planning on modifying this patch slightly so that it flows through ParseDeclSpecifier and handles attributes and other invalid decl-specifiers such as static etc. more gracefully on a concept decl. I have this partially implemented - my hope is to get this done v soonish so feel free to ping me if you don't hear anything about this in a week or so ...

[rsmith]

include/clang/AST/DeclTemplate.h

3015

This comment isn't appropriate. Please just describe what the node is. (And note that a definition is a kind of declaration, despite common parlance.)

3035

Please remove this again. ASTDeclReader should set the ConstraintExpr field directly. The AST is intended to be immutable after creation, so should generally not have setters.

3043

There's a bigger problem here:

TemplateDecl *TD = /*some ConceptDecl*/;
auto SR = TD->getSourceRange(); // crash

TemplateDecl has a hard assumption that it contains a TemplatedDecl. So, three options:

1. Change TemplateDecl and all its users to remove this assumption (hard and leads to an awkward-to-use AST)
2. Add a Decl subclass that acts as the templated declaration in a concept declaration (corresponding to the C++ grammar's concept-definition production)
3. Make ConceptDecl not derive from a TemplateDecl at all

I think option 2 is my preference, but option 3 is also somewhat appealing (there are other ways in which a concept is not a template: for instance, it cannot be constrained, and it cannot be classified as either a type template or a non-type template, because its kind depends on the context in which it appears).

Of course, this leads to one of the Hard Problems Of Computer Science: naming things. ConceptDecl for a concept-definition and ConceptTemplateDecl for the template-head concept-definition would be consistent with the rest of the AST. It's a little unfortunate for the longer name to be the AST node that we actually interact with, but the consistency is probably worth the cost.

include/clang/AST/RecursiveASTVisitor.h

1759

Hmm, concepts don't really have specializations, though, do they? (Much like alias templates.) And because they're substituted incrementally, and the result of evaluation can vary at different points in the same translation unit, it's not obvious how much we can actually cache.

I suppose I'll see this was handled in later patches in the series :)

include/clang/Basic/DiagnosticParseKinds.td

1225

I would expect something more general here. For an alias-declaration, we say:

"error: name defined in alias declaration must be an identifier"

This is then also appropriate for other kinds of invalid concept-names such as

template<typename T> concept operator int = true;

include/clang/Basic/DiagnosticSemaKinds.td

2437–2438

"must be 'bool'" doesn't make sense. Maybe "constraint expression must be of type 'bool' but is of type %0" or similar?

2441–2442

Do not use "may not" in this context; it's ambiguous (this could be read as "I'm not sure if this concept has associated constraints"). Use "cannot" instead.

(And generally prefer "can" over "may" or "must" in diagnostics.)

2443–2444

Please make this a bit less informal and a little more informative. Perhaps "sorry, unimplemented concepts feature used". For a temporary "under construction" error, it's also OK to include a %0 and pass in a string describing the feature if you like.

2445–2446

maybe not -> cannot

include/clang/Basic/TemplateKinds.h

19

Note this comment. You need to track down the diagnostics that use this enum and update their %selects to cover the new name kind.

lib/AST/DeclBase.cpp

731–734

This comment just repeats what the comment before it already says: please remove it again.

lib/Parse/ParseTemplate.cpp

160–163

No need. If you see a kw_concept keyword, you have the language feature enabled.

376–379

Please also check for a < after the identifier, and diagnose the attempt to form a concept partial / explicit specialization. (I'm fine with leaving that to a later patch if you prefer.)

One option would be to call ParseUnqualifiedId and then diagnose anything that's not a simple identifier. (See ParseAliasDeclarationAfterDeclarator for how we do this for alias declarations.)

385

Use tok::equal here, not a string literal.

392

This diagnostic doesn't take an argument.

lib/Sema/SemaTemplate.cpp

4185–4186

This needs rebasing onto SVN trunk. (We have lambda'fied the dependent arguments check there.)

7887

You need to check CurContext->getRedeclContext(). A concept can be defined in a LinkageSpecDecl (with C++ linkage) or an ExportDecl, for instance.

7911–7912

ConceptDecl::Create cannot return null. Checking this doesn't make sense, because (a) this is dead code, and (b) if this happened, you would return null without issuing a diagnostic.

[saar.raz]

include/clang/AST/DeclTemplate.h

3043

The dummy decl is pretty confusing and will be a very weird decl in and of itself. I can't think of a good name right now, but your proposed naming will be pretty confusing given that a ConceptTemplateDecl does not template a concept declaration given the meaning of the phrase in the standard... Maybe ConceptBodyDecl? ConceptDummyDecl? ConceptDefinitionDecl? We need something that screams "this is not interesting" for the AST usage to be reasonable.
Option 3 feels like loads of code duplication.
I'm not entirely sure how many blind (through TemplateDecl) uses of getTemplatedDecl there are, but there might not be that many, in which case the first option might be the lesser of all these evils.

[saar.raz]

Address most of rsmith's CR comments, rebase onto trunk

[saar.raz]

Only the TemplatedDecl issue remains, all other comments have been addressed and we're rebased onto master.
@rsmith please reply to the last comment, and lets finally start merging these :)

[rsmith]

Thanks!

Please revert the (presumably unintended) mode changes to the ptxas executables.

include/clang/AST/DeclTemplate.h

3016

This should also derive from Mergeable<ConceptDecl>, since we are permitted to merge multiple definitions of the same concept across translation units by C++20 [basic.def.odr]/12.

3043

Faisal's comment is marked "Done" but not done.

ConceptBodyDecl or something like it seems reasonable. But I think we can consider that after landing this patch, and leave the templated declaration null for now.

include/clang/Basic/DiagnosticParseKinds.td

1260–1270

Generally we don't leave blank lines between diagnostic definitions, and instead use the continuation indent to visually separate them.

1261–1263

The phrasing of this (particularly the "if any") is a little confusing. I think it's fine to just use the err_concept_definition_not_identifier diagnostic for this case.

1269

I'd probably phrase this as

"ISO C++2a does not permit the 'bool' keyword after 'concept'"

(The Concepts TS isn't really the past -- TSes are more like an alternative reality -- so "no longer" is a bit odd.) I'd also be tempted to turn this into an ExtWarn so that we can accept code targeting the Concepts TS with a warning.

include/clang/Basic/DiagnosticSemaKinds.td

2443

Drop the ", did you attempt this?". It doesn't add anything to the diagnostic, and might be read as a little snarky, frustrating the user.

lib/AST/ASTDumper.cpp

182–186 ↗

(On Diff #194417)

This needs rebasing; I believe the right place for this is now split between TextNodeDumper.cpp and ASTNodeTraverser.h.

lib/AST/DeclPrinter.cpp

1091–1092

This looks wrong: we'll only print the template parameters, and not the concept <name> = <expr>; part. Please add another else if for the ConceptDecl case (or similar).

lib/Index/IndexDecl.cpp

658–662

This change looks redundant. Note that VisitTemplateDecl below already returned true if getTemplatedDecl() is null.

lib/Parse/ParseTemplate.cpp

58

There's no 'export'[opt] in template-head.

387

Consider calling DiagnoseAndSkipCXX11Attributes before and after parsing the name of the concept; it seems likely that people will try adding attributes there, and we should give a good diagnostic for this until they start being permitted in one of those two locations.

lib/Sema/SemaTemplate.cpp

7928

This should be PushOnScopeChains(NewDecl, S); instead (though I think in practice it won't matter until/unless we start supporting block-scope concept definitions).

lib/Sema/SemaTemplateInstantiateDecl.cpp

3365

No need for a return here; the code after an llvm_unreachable is unreachable =)

lib/Serialization/ASTReaderDecl.cpp

2082

Call mergeMergeable(D) at the end of this.

[saar.raz]

Address CR comments by rsmith

[saar.raz]

@rsmith are we done with CR on this?

[rsmith]

LGTM with a few mechanical updates.

include/clang/Basic/DiagnosticParseKinds.td

1262

ExtWarn diagnostics should be named ext_ not err_. (This is important because readers of the code emitting the diagnostic need to know whether they can mark things as invalid (etc) during error recovery -- which is only correct to do after emitting an error.)

include/clang/Sema/Sema.h

6676

Nit: please wrap the first parameter onto the next line.

lib/AST/DeclTemplate.cpp

833–834

Yes, you need that :)

(You should be able to check this with -ast-dump: for a concept in a namespace, its template parameters should have the namespace as their semantic DeclContext, not the translation unit. This also has some impact on merging of default argument visibility with modules.)

lib/Index/IndexDecl.cpp

677

Please revert the addition of the unused first parameter.

[saar.raz]

• Address final CR comments by rsmith

[saar.raz]

Awesome! I do not have commit permissions though, so can you do the actual commit?

[saar.raz]

@rsmith?

[saar.raz]

Final committed diff.

include/clang/AST/ASTNodeTraverser.h

public:
   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());
     if (D->hasDefaultArgument())
       dumpTemplateArgumentLoc(
           D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
           D->defaultArgumentWasInherited() ? "inherited from" : "previous");
   }
 
+  void VisitConceptDecl(const ConceptDecl *D) {
+    dumpTemplateParameters(D->getTemplateParameters());
+    Visit(D->getConstraintExpr());
+  }
+
   void VisitUsingShadowDecl(const UsingShadowDecl *D) {
     if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
       Visit(TD->getTypeForDecl());
   }
 
   void VisitFriendDecl(const FriendDecl *D) {
     if (!D->getFriendType())
       Visit(D->getFriendDecl());

include/clang/AST/DeclTemplate.h

spec_iterator spec_end() const {
     return makeSpecIterator(getSpecializations(), true);
   }
 
   // Implement isa/cast/dyncast support
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == VarTemplate; }
 };
 
+// \brief Declaration of a C++2a concept.
+class ConceptDecl : public TemplateDecl, public Mergeable<ConceptDecl> {
+protected:
+  Expr *ConstraintExpr;
+
+  ConceptDecl(DeclContext *DC,
+              SourceLocation L, DeclarationName Name,
+              TemplateParameterList *Params,
+              Expr *ConstraintExpr)
+      : TemplateDecl(nullptr, Concept, DC, L, Name, Params),
+        ConstraintExpr(ConstraintExpr) {};
+public:
+  static ConceptDecl *Create(ASTContext &C, DeclContext *DC,
+                             SourceLocation L, DeclarationName Name,
+                             TemplateParameterList *Params,
+                             Expr *ConstraintExpr);
+  static ConceptDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+  Expr *getConstraintExpr() const {
+    return ConstraintExpr;
+  }
+
+  SourceRange getSourceRange() const override LLVM_READONLY {
+    return SourceRange(getTemplateParameters()->getTemplateLoc(),
+                       ConstraintExpr->getEndLoc());
+  }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == Concept; }
+
+  friend class ASTReader;
+  friend class ASTDeclReader;
+  friend class ASTDeclWriter;
+};
+
 inline NamedDecl *getAsNamedDecl(TemplateParameter P) {
   if (auto *PD = P.dyn_cast<TemplateTypeParmDecl *>())
     return PD;
   if (auto *PD = P.dyn_cast<NonTypeTemplateParmDecl *>())
     return PD;
   return P.get<TemplateTemplateParmDecl *>();
 }
 

include/clang/AST/RecursiveASTVisitor.h

/* Note that getInstantiatedFromMemberTemplate() is just a link            \
        from a template instantiation back to the template from which           \
        it was instantiated, and thus should not be traversed. */               \
   })
 
 DEF_TRAVERSE_TMPL_DECL(Class)
 DEF_TRAVERSE_TMPL_DECL(Var)
 DEF_TRAVERSE_TMPL_DECL(Function)
 
 DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
   // D is the "T" in something like
   //   template <template <typename> class T> class container { };
   TRY_TO(TraverseDecl(D->getTemplatedDecl()));
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));
   }
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
 DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
DEF_TRAVERSE_DECL(TypeAliasDecl, {
   // source.
 })
 
 DEF_TRAVERSE_DECL(TypeAliasTemplateDecl, {
   TRY_TO(TraverseDecl(D->getTemplatedDecl()));
   TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
 })
 
+DEF_TRAVERSE_DECL(ConceptDecl, {
+  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
+  TRY_TO(TraverseStmt(D->getConstraintExpr()));
+})
+
 DEF_TRAVERSE_DECL(UnresolvedUsingTypenameDecl, {
   // A dependent using declaration which was marked with 'typename'.
   //   template<class T> class A : public B<T> { using typename B<T>::foo; };
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   // We shouldn't traverse D->getTypeForDecl(); it's a result of
   // declaring the type, not something that was written in the
   // source.
 })

include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
   void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
   void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
   void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
   void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
   void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
   void VisitBlockDecl(const BlockDecl *D);
+  void VisitConceptDecl(const ConceptDecl *D);
 
 private:
   void dumpCXXTemporary(const CXXTemporary *Temporary);
 };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_TEXTNODEDUMPER_H

include/clang/Basic/DeclNodes.td

def Named : Decl<"named declarations", 1>;
   def Template : DDecl<Named, "templates", 1>;
     def RedeclarableTemplate : DDecl<Template, "redeclarable templates", 1>;
       def FunctionTemplate : DDecl<RedeclarableTemplate>;
       def ClassTemplate : DDecl<RedeclarableTemplate>;
       def VarTemplate : DDecl<RedeclarableTemplate>;
       def TypeAliasTemplate : DDecl<RedeclarableTemplate>;
     def TemplateTemplateParm : DDecl<Template>;
     def BuiltinTemplate : DDecl<Template>;
+    def Concept : DDecl<Template>;
   def Using : DDecl<Named>;
   def UsingPack : DDecl<Named>;
   def UsingShadow : DDecl<Named>;
     def ConstructorUsingShadow : DDecl<UsingShadow>;
   def ObjCMethod : DDecl<Named, "Objective-C methods">, DeclContext;
   def ObjCContainer : DDecl<Named, "Objective-C containers", 1>, DeclContext;
     def ObjCCategory : DDecl<ObjCContainer>;
     def ObjCProtocol : DDecl<ObjCContainer, "Objective-C protocols">;

include/clang/Basic/DiagnosticParseKinds.td

def ext_template_template_param_typename : ExtWarn<
   InGroup<CXX17>;
 def warn_cxx14_compat_template_template_param_typename : Warning<
   "template template parameter using 'typename' is "
   "incompatible with C++ standards before C++17">,
   InGroup<CXXPre17Compat>, DefaultIgnore;
 def err_template_spec_syntax_non_template : Error<
   "identifier followed by '<' indicates a class template specialization but "
   "%0 %select{does not refer to a template|refers to a function template|"
-  "<unused>|refers to a variable template|<unused>}1">;
+  "<unused>|refers to a variable template|<unused>|refers to a concept}1">;
 def err_id_after_template_in_nested_name_spec : Error<
   "expected template name after 'template' keyword in nested name specifier">;
 def err_unexpected_template_in_unqualified_id : Error<
   "'template' keyword not permitted here">;
 def err_two_right_angle_brackets_need_space : Error<
   "a space is required between consecutive right angle brackets (use '> >')">;
 def err_right_angle_bracket_equal_needs_space : Error<
   "a space is required between a right angle bracket and an equals sign "
def err_pragma_cannot_end_force_cuda_host_device : Error<
   "force_cuda_host_device end pragma without matching "
   "force_cuda_host_device begin">;
 } // end of Parse Issue category.
 
 let CategoryName = "Modules Issue" in {
 def err_unexpected_module_decl : Error<
   "module declaration can only appear at the top level">;
 def err_module_expected_ident : Error<
   "expected a module name after '%select{module|import}0'">;
 def err_module_implementation_partition : Error<
   "module partition must be declared 'export'">;
 def err_attribute_not_module_attr : Error<
   "%0 attribute cannot be applied to a module">;
 def err_attribute_not_import_attr : Error<
   "%0 attribute cannot be applied to a module import">;
 def err_module_expected_semi : Error<
   "expected ';' after module name">;
def note_meant_to_use_typename : Note<
   "did you mean to use 'typename'?">;
 }
 
 let CategoryName = "Coroutines Issue" in {
 def err_for_co_await_not_range_for : Error<
   "'co_await' modifier can only be applied to range-based for loop">;
 }
 
+let CategoryName = "Concepts Issue" in {
+def err_concept_definition_not_identifier : Error<
+  "name defined in concept definition must be an identifier">;
+def err_concept_legacy_bool_keyword : ExtWarn<
+  "ISO C++2a does not permit the 'bool' keyword after 'concept'">,
+  InGroup<DiagGroup<"concepts-ts-compat">>;
+}
+
 } // end of Parser diagnostics

include/clang/Basic/DiagnosticSemaKinds.td

 def err_illegal_decl_array_of_auto : Error<
   "'%0' declared as array of %1">;
 def err_new_array_of_auto : Error<
   "cannot allocate array of 'auto'">;
 def err_auto_not_allowed : Error<
   "%select{'auto'|'decltype(auto)'|'__auto_type'|"
   "use of "
   "%select{class template|function template|variable template|alias template|"
-  "template template parameter|template}2 %3 requires template arguments; "
-  "argument deduction}0 not allowed "
+  "template template parameter|concept|template}2 %3 requires template "
+  "arguments; argument deduction}0 not allowed "
   "%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"

 
 // C++17 deduced class template specialization types
 def err_deduced_class_template_compound_type : Error<
   "cannot %select{form pointer to|form reference to|form array of|"
   "form function returning|use parentheses when declaring variable with}0 "
   "deduced class template specialization type">;
 def err_deduced_non_class_template_specialization_type : Error<
   "%select{<error>|function template|variable template|alias template|"
-  "template template parameter|template}0 %1 requires template arguments; "
-  "argument deduction only allowed for class templates">;
+  "template template parameter|concept|template}0 %1 requires template "
+  "arguments; argument deduction only allowed for class templates">;
 def err_deduced_class_template_ctor_ambiguous : Error<
   "ambiguous deduction for template arguments of %0">;
 def err_deduced_class_template_ctor_no_viable : Error<
   "no viable constructor or deduction guide for deduction of "
   "template arguments of %0">;
 def err_deduced_class_template_incomplete : Error<
   "template %0 has no definition and no %select{|viable }1deduction guides "
   "for deduction of template arguments">;

 def err_deduction_guide_with_complex_decl : Error<
   "cannot specify any part of a return type in the "
   "declaration of a deduction guide">;
 def err_deduction_guide_invalid_specifier : Error<
   "deduction guide cannot be declared '%0'">;
 def err_deduction_guide_name_not_class_template : Error<
   "cannot specify deduction guide for "
   "%select{<error>|function template|variable template|alias template|"
-  "template template parameter|dependent template name}0 %1">;
+  "template template parameter|concept|dependent template name}0 %1">;
 def err_deduction_guide_wrong_scope : Error<
   "deduction guide must be declared in the same scope as template %q0">;
 def err_deduction_guide_defines_function : Error<
   "deduction guide cannot have a function definition">;
 def err_deduction_guide_explicit_mismatch : Error<
   "deduction guide is %select{not |}0declared 'explicit' but "
   "previous declaration was%select{ not|}0">;
 def err_deduction_guide_specialized : Error<"deduction guide cannot be "

 def note_non_literal_lambda : Note<
   "lambda closure types are non-literal types before C++17">;
 def warn_private_extern : Warning<
   "use of __private_extern__ on a declaration may not produce external symbol "
   "private to the linkage unit and is deprecated">, InGroup<PrivateExtern>;
 def note_private_extern : Note<
   "use __attribute__((visibility(\"hidden\"))) attribute instead">;
 
-// C++ Concepts TS
-def err_concept_wrong_decl_kind : Error<
-  "'concept' can only appear on the definition of a function template or variable template">;
-def err_concept_decls_may_only_appear_in_namespace_scope : Error<
-  "concept declarations may only appear in namespace scope">;
-def err_function_concept_not_defined : Error<
-  "function concept declaration must be a definition">;
-def err_var_concept_not_initialized : Error<
-  "variable concept declaration must be initialized">;
-def err_function_concept_exception_spec : Error<
-  "function concept cannot have exception specification">;
-def err_concept_decl_invalid_specifiers : Error<
-  "%select{variable|function}0 concept cannot be declared "
-  "'%select{thread_local|inline|friend|constexpr}1'">;
-def err_function_concept_with_params : Error<
-  "function concept cannot have any parameters">;
-def err_function_concept_bool_ret : Error<
-  "declared return type of function concept must be 'bool'">;
-def err_variable_concept_bool_decl : Error<
-  "declared type of variable concept must be 'bool'">;
-def err_concept_specified_specialization : Error<
-  "'concept' cannot be applied on an "
-  "%select{explicit instantiation|explicit specialization|partial specialization}0">;
-def err_concept_specialized : Error<
-  "%select{function|variable}0 concept cannot be "
-  "%select{explicitly instantiated|explicitly specialized|partially specialized}1">;
+// C++ Concepts
+def err_concept_initialized_with_non_bool_type : Error<
+  "constraint expression must be of type 'bool' but is of type %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_no_parameters : Error<
+  "concept template parameter list must have at least one parameter; explicit "
+  "specialization of concepts is not allowed">;
+def err_concept_extra_headers : Error<
+  "extraneous template parameter list in concept definition">;
+def err_concept_no_associated_constraints : Error<
+  "concept cannot have associated constraints">;
+def err_concept_not_implemented : Error<
+  "sorry, unimplemented concepts feature %0 used">;
 
 def err_template_different_associated_constraints : Error<
   "associated constraints differ in template redeclaration">;
 
 // C++11 char16_t/char32_t
 def warn_cxx98_compat_unicode_type : Warning<
   "'%0' type specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
def err_template_member_noparams : Error<
   "extraneous 'template<>' in declaration of member %0">;
 def err_template_tag_noparams : Error<
   "extraneous 'template<>' in declaration of %0 %1">;
 
 // C++ Template Argument Lists
 def err_template_missing_args : Error<
   "use of "
   "%select{class template|function template|variable template|alias template|"
-  "template template parameter|template}0 %1 requires template arguments">;
+  "template template parameter|concept|template}0 %1 requires template "
+  "arguments">;
 def err_template_arg_list_different_arity : Error<
   "%select{too few|too many}0 template arguments for "
   "%select{class template|function template|variable template|alias template|"
-  "template template parameter|template}1 %2">;
+  "template template parameter|concept|template}1 %2">;
 def note_template_decl_here : Note<"template is declared here">;
 def err_template_arg_must_be_type : Error<
   "template argument for template type parameter must be a type">;
 def err_template_arg_must_be_type_suggest : Error<
   "template argument for template type parameter must be a type; "
   "did you forget 'typename'?">;
 def ext_ms_template_type_arg_missing_typename : ExtWarn<
   "template argument for template type parameter must be a type; "

include/clang/Basic/TemplateKinds.h

 ///
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_BASIC_TEMPLATEKINDS_H
 #define LLVM_CLANG_BASIC_TEMPLATEKINDS_H
 
 namespace clang {
 
 /// Specifies the kind of template name that an identifier refers to.
 /// Be careful when changing this: this enumeration is used in diagnostics.
 enum TemplateNameKind {
   /// The name does not refer to a template.
   TNK_Non_template = 0,
   /// The name refers to a function template or a set of overloaded
   /// functions that includes at least one function template.
   TNK_Function_template,
   /// The name refers to a template whose specialization produces a
   /// type. The template itself could be a class template, template
enum TemplateNameKind {
   /// };
   /// \endcode
   ///
   /// Here, "apply" is a dependent template name within the typename
   /// specifier in the typedef. "apply" is a nested template, and
   /// whether the template name is assumed to refer to a type template or a
   /// function template depends on the context in which the template
   /// name occurs.
-  TNK_Dependent_template_name
+  TNK_Dependent_template_name,
+  TNK_Concept_template
 };
 
 }
 #endif
-
-

include/clang/Parse/Parser.h

private:
   ParsedTemplateArgument ParseTemplateTemplateArgument();
   ParsedTemplateArgument ParseTemplateArgument();
   Decl *ParseExplicitInstantiation(DeclaratorContext Context,
                                    SourceLocation ExternLoc,
                                    SourceLocation TemplateLoc,
                                    SourceLocation &DeclEnd,
                                    ParsedAttributes &AccessAttrs,
                                    AccessSpecifier AS = AS_none);
+  // C++2a: Template, concept definition [temp]
+  Decl *
+  ParseConceptDefinition(const ParsedTemplateInfo &TemplateInfo,
+                         SourceLocation &DeclEnd);
 
   //===--------------------------------------------------------------------===//
   // Modules
   DeclGroupPtrTy ParseModuleDecl();
   Decl *ParseModuleImport(SourceLocation AtLoc);
   bool parseMisplacedModuleImport();
   bool tryParseMisplacedModuleImport() {
     tok::TokenKind Kind = Tok.getKind();

include/clang/Sema/Sema.h

public:
 
   /// Describes the detailed kind of a template name. Used in diagnostics.
   enum class TemplateNameKindForDiagnostics {
     ClassTemplate,
     FunctionTemplate,
     VarTemplate,
     AliasTemplate,
     TemplateTemplateParam,
+    Concept,
     DependentTemplate
   };
   TemplateNameKindForDiagnostics
   getTemplateNameKindForDiagnostics(TemplateName Name);
 
   /// Determine whether it's plausible that E was intended to be a
   /// template-name.
   bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
                                 const TemplateArgumentListInfo &TemplateArgs);
 
   ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
                                 const DeclarationNameInfo &NameInfo,
                                 VarTemplateDecl *Template,
                                 SourceLocation TemplateLoc,
                                 const TemplateArgumentListInfo *TemplateArgs);
 
+  ExprResult
+  CheckConceptTemplateId(const CXXScopeSpec &SS,
+                         const DeclarationNameInfo &NameInfo,
+                         ConceptDecl *Template,
+                         SourceLocation TemplateLoc,
+                         const TemplateArgumentListInfo *TemplateArgs);
+
   void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);
 
   ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                  SourceLocation TemplateKWLoc,
                                  LookupResult &R,
                                  bool RequiresADL,
                                const TemplateArgumentListInfo *TemplateArgs);
 

   getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                   const TemplateArgumentList &Args);
 
   std::string
   getTemplateArgumentBindingsText(const TemplateParameterList *Params,
                                   const TemplateArgument *Args,
                                   unsigned NumArgs);
 
+  // Concepts
+  Decl *ActOnConceptDefinition(Scope *S,
+      MultiTemplateParamsArg TemplateParameterLists, IdentifierInfo *Name,
+      SourceLocation NameLoc, Expr *ConstraintExpr);
+
   //===--------------------------------------------------------------------===//
   // 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();
 

include/clang/Serialization/ASTBitCodes.h

enum DeclCode {
       DECL_NON_TYPE_TEMPLATE_PARM,
 
       /// A TemplateTemplateParmDecl record.
       DECL_TEMPLATE_TEMPLATE_PARM,
 
       /// A TypeAliasTemplateDecl record.
       DECL_TYPE_ALIAS_TEMPLATE,
 
-      /// A StaticAssertDecl record.
+      /// \brief A ConceptDecl record.
+      DECL_CONCEPT,
+
+      /// \brief A StaticAssertDecl record.
       DECL_STATIC_ASSERT,
 
       /// A record containing CXXBaseSpecifiers.
       DECL_CXX_BASE_SPECIFIERS,
 
       /// A record containing CXXCtorInitializers.
       DECL_CXX_CTOR_INITIALIZERS,
 

lib/AST/ASTStructuralEquivalence.cpp

if (!IsTemplateDeclCommonStructurallyEquivalent(Context, D1, D2))
     return false;
 
   // Check the templated declaration.
   return IsStructurallyEquivalent(Context, D1->getTemplatedDecl()->getType(),
                                   D2->getTemplatedDecl()->getType());
 }
 
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
+                                     ConceptDecl *D1,
+                                     ConceptDecl *D2) {
+  // Check template parameters.
+  if (!IsTemplateDeclCommonStructurallyEquivalent(Context, D1, D2))
+    return false;
+
+  // Check the constraint expression.
+  return IsStructurallyEquivalent(Context, D1->getConstraintExpr(),
+                                  D2->getConstraintExpr());
+}
+
+static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      FriendDecl *D1, FriendDecl *D2) {
   if ((D1->getFriendType() && D2->getFriendDecl()) ||
       (D1->getFriendDecl() && D2->getFriendType())) {
       return false;
   }
   if (D1->getFriendType() && D2->getFriendType())
     return IsStructurallyEquivalent(Context,
                                     D1->getFriendType()->getType(),
if (auto *Record1 = dyn_cast<RecordDecl>(D1)) {
     if (auto *FunctionTemplate2 = dyn_cast<FunctionTemplateDecl>(D2)) {
       if (!::IsStructurallyEquivalent(*this, FunctionTemplate1,
                                       FunctionTemplate2))
         return false;
     } else {
       // Class template/non-class-template mismatch.
       return false;
     }
+  } else if (auto *ConceptDecl1 = dyn_cast<ConceptDecl>(D1)) {
+    if (auto *ConceptDecl2 = dyn_cast<ConceptDecl>(D2)) {
+      if (!::IsStructurallyEquivalent(*this, ConceptDecl1, ConceptDecl2))
+        return false;
+    } else {
+      // Concept/non-concept mismatch.
+      return false;
+    }
   } else if (auto *TTP1 = dyn_cast<TemplateTypeParmDecl>(D1)) {
     if (auto *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
       if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
         return false;
     } else {
       // Kind mismatch.
       return false;
     }

lib/AST/DeclBase.cpp

switch (DeclKind) {
     case Label:
       return IDNS_Label;
     case IndirectField:
       return IDNS_Ordinary | IDNS_Member;
 
     case Binding:
     case NonTypeTemplateParm:
     case VarTemplate:
+    case Concept:
       // These (C++-only) declarations are found by redeclaration lookup for
       // tag types, so we include them in the tag namespace.
       return IDNS_Ordinary | IDNS_Tag;
 
     case ObjCCompatibleAlias:
     case ObjCInterface:
       return IDNS_Ordinary | IDNS_Type;
 
     case Typedef:
     case TypeAlias:
     case TemplateTypeParm:
     case ObjCTypeParam:
       return IDNS_Ordinary | IDNS_Type;
 
switch (DeclKind) {
     case TypeAliasTemplate:
       return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
 
     case OMPDeclareReduction:
       return IDNS_OMPReduction;
 
     case OMPDeclareMapper:
       return IDNS_OMPMapper;
 
     // Never have names.
     case Friend:
     case FriendTemplate:
     case AccessSpec:
     case LinkageSpec:
     case Export:
     case FileScopeAsm:
     case StaticAssert:

lib/AST/DeclPrinter.cpp

void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
   printTemplateParameters(D->getTemplateParameters());
 
   if (const TemplateTemplateParmDecl *TTP =
         dyn_cast<TemplateTemplateParmDecl>(D)) {
     Out << "class ";
     if (TTP->isParameterPack())
       Out << "...";
     Out << D->getName();
-  } else {
-    Visit(D->getTemplatedDecl());
+  } else if (auto *TD = D->getTemplatedDecl())
+    Visit(TD);
+  else if (const auto *Concept = dyn_cast<ConceptDecl>(D)) {
+    Out << "concept " << Concept->getName() << " = " ;
+    Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy,
+                                              Indentation);
+    Out << ";";
   }
 }
 
 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   prettyPrintPragmas(D->getTemplatedDecl());
   // Print any leading template parameter lists.
   if (const FunctionDecl *FD = D->getTemplatedDecl()) {
     for (unsigned I = 0, NumTemplateParams = FD->getNumTemplateParameterLists();
          I < NumTemplateParams; ++I)
       printTemplateParameters(FD->getTemplateParameterList(I));

lib/AST/DeclTemplate.cpp

else {
     if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
       return ctd->getSourceRange();
     return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
       ->getSourceRange();
   }
 }
 
 //===----------------------------------------------------------------------===//
+// ConceptDecl Implementation
+//===----------------------------------------------------------------------===//
+ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
+                                 SourceLocation L, DeclarationName Name,
+                                 TemplateParameterList *Params,
+                                 Expr *ConstraintExpr) {
+  // TODO: Do we need this?
+  //  AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
+  return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
+}
+
+ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C,
+                                             unsigned ID) {
+  ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
+                                                DeclarationName(),
+                                                nullptr, nullptr);
+
+  return Result;
+}
+
+//===----------------------------------------------------------------------===//
 // ClassTemplatePartialSpecializationDecl Implementation
 //===----------------------------------------------------------------------===//
 void ClassTemplatePartialSpecializationDecl::anchor() {}
 
 ClassTemplatePartialSpecializationDecl::
 ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
                                        DeclContext *DC,
                                        SourceLocation StartLoc,

lib/AST/TextNodeDumper.cpp

 
 void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
   if (D->isVariadic())
     OS << " variadic";
 
   if (D->capturesCXXThis())
     OS << " captures_this";
 }
+
+void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
+  dumpName(D);
+}
 No newline at end of file

lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
   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:
     // 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/CodeGenModule.cpp

case Decl::CXXRecord:
     for (auto *I : cast<CXXRecordDecl>(D)->decls())
       if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
         EmitTopLevelDecl(I);
     break;
     // No code generation needed.
   case Decl::UsingShadow:
   case Decl::ClassTemplate:
   case Decl::VarTemplate:
+  case Decl::Concept:
   case Decl::VarTemplatePartialSpecialization:
   case Decl::FunctionTemplate:
   case Decl::TypeAliasTemplate:
   case Decl::Block:
   case Decl::Empty:
   case Decl::Binding:
     break;
   case Decl::Using:          // using X; [C++]

lib/Index/IndexDecl.cpp

IndexCtx.indexTagDecl(
         D, SymbolRelation(SymbolRoleSet(SymbolRole::RelationSpecializationOf),
                           SpecializationOf));
     if (TypeSourceInfo *TSI = D->getTypeAsWritten())
       IndexCtx.indexTypeSourceInfo(TSI, /*Parent=*/nullptr,
                                    D->getLexicalDeclContext());
     return true;
   }
 
-  static bool shouldIndexTemplateParameterDefaultValue(const NamedDecl *D) {
-    if (!D)
-      return false;
+  static bool shouldIndexTemplateParameterDefaultValue(const TemplateDecl *TD,
+                                                       const NamedDecl *D) {
     // We want to index the template parameters only once when indexing the
     // canonical declaration.
+    if (!D)
+      return false;
     if (const auto *FD = dyn_cast<FunctionDecl>(D))
       return FD->getCanonicalDecl() == FD;
     else if (const auto *TD = dyn_cast<TagDecl>(D))
       return TD->getCanonicalDecl() == TD;
     else if (const auto *VD = dyn_cast<VarDecl>(D))
       return VD->getCanonicalDecl() == VD;
     return true;
   }
 
   bool VisitTemplateDecl(const TemplateDecl *D) {
 
     const NamedDecl *Parent = D->getTemplatedDecl();
     if (!Parent)
       return true;
 
     // Index the default values for the template parameters.
     if (D->getTemplateParameters() &&
-        shouldIndexTemplateParameterDefaultValue(Parent)) {
+        shouldIndexTemplateParameterDefaultValue(D, Parent)) {
       const TemplateParameterList *Params = D->getTemplateParameters();
       for (const NamedDecl *TP : *Params) {
         if (IndexCtx.shouldIndexTemplateParameters())
           IndexCtx.handleDecl(TP);
         if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(TP)) {
           if (TTP->hasDefaultArgument())
             IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
         } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {

lib/Parse/ParseTemplate.cpp

 /// followed by a (possibly templated) declaration. Since the
 /// syntactic form of both features is nearly identical, we parse all
 /// of the template headers together and let semantic analysis sort
 /// the declarations from the explicit specializations.
 ///
 ///       template-declaration: [C++ temp]
 ///         'export'[opt] 'template' '<' template-parameter-list '>' declaration
 ///
+///       template-declaration: [C++2a]
+///         template-head declaration
+///         template-head concept-definition
+///
+///       TODO: requires-clause
+///       template-head: [C++2a]
+///         'template' '<' template-parameter-list '>'
+///             requires-clause[opt]
+///
 ///       explicit-specialization: [ C++ temp.expl.spec]
 ///         'template' '<' '>' declaration
 Decl *Parser::ParseTemplateDeclarationOrSpecialization(
     DeclaratorContext Context, SourceLocation &DeclEnd,
     ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
   assert(Tok.isOneOf(tok::kw_export, tok::kw_template) &&
          "Token does not start a template declaration.");
 
ParamLists.push_back(Actions.ActOnTemplateParameterList(
         CurTemplateDepthTracker.getDepth(), ExportLoc, TemplateLoc, LAngleLoc,
         TemplateParams, RAngleLoc, OptionalRequiresClauseConstraintER.get()));
   } while (Tok.isOneOf(tok::kw_export, tok::kw_template));
 
   unsigned NewFlags = getCurScope()->getFlags() & ~Scope::TemplateParamScope;
   ParseScopeFlags TemplateScopeFlags(this, NewFlags, isSpecialization);
 
   // Parse the actual template declaration.
+  if (Tok.is(tok::kw_concept))
+    return ParseConceptDefinition(
+        ParsedTemplateInfo(&ParamLists, isSpecialization,
+                           LastParamListWasEmpty),
+        DeclEnd);
+
   return ParseSingleDeclarationAfterTemplate(
       Context,
       ParsedTemplateInfo(&ParamLists, isSpecialization, LastParamListWasEmpty),
       ParsingTemplateParams, DeclEnd, AccessAttrs, AS);
 }
 
 /// Parse a single declaration that declares a template,
 /// template specialization, or explicit instantiation of a template.
 ///
 /// \param DeclEnd will receive the source location of the last token
 /// within this declaration.
 ///
 /// \param AS the access specifier associated with this
 /// declaration. Will be AS_none for namespace-scope declarations.
 ///
 /// \returns the new declaration.
 Decl *Parser::ParseSingleDeclarationAfterTemplate(
     DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
     ParsingDeclRAIIObject &DiagsFromTParams, SourceLocation &DeclEnd,
     ParsedAttributes &AccessAttrs, AccessSpecifier AS) {
   assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
          "Template information required");
 
   if (Tok.is(tok::kw_static_assert)) {
     // A static_assert declaration may not be templated.
     Diag(Tok.getLocation(), diag::err_templated_invalid_declaration)
       << TemplateInfo.getSourceRange();
     // Parse the static_assert declaration to improve error recovery.
     return ParseStaticAssertDeclaration(DeclEnd);
Decl *Parser::ParseSingleDeclarationAfterTemplate(
   // Eat the semi colon after the declaration.
   ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
   if (LateParsedAttrs.size() > 0)
     ParseLexedAttributeList(LateParsedAttrs, ThisDecl, true, false);
   DeclaratorInfo.complete(ThisDecl);
   return ThisDecl;
 }
 
+/// \brief Parse a single declaration that declares a concept.
+///
+/// \param DeclEnd will receive the source location of the last token
+/// within this declaration.
+///
+/// \returns the new declaration.
+Decl *
+Parser::ParseConceptDefinition(const ParsedTemplateInfo &TemplateInfo,
+                               SourceLocation &DeclEnd) {
+  assert(TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
+         "Template information required");
+  assert(Tok.is(tok::kw_concept) &&
+         "ParseConceptDefinition must be called when at a 'concept' keyword");
+
+  ConsumeToken(); // Consume 'concept'
+
+  SourceLocation BoolKWLoc;
+  if (TryConsumeToken(tok::kw_bool, BoolKWLoc))
+    Diag(Tok.getLocation(), diag::err_concept_legacy_bool_keyword) <<
+        FixItHint::CreateRemoval(SourceLocation(BoolKWLoc));
+
+  DiagnoseAndSkipCXX11Attributes();
+
+  CXXScopeSpec SS;
+  if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(),
+      /*EnteringContext=*/false, /*MayBePseudoDestructor=*/nullptr,
+      /*IsTypename=*/false, /*LastII=*/nullptr, /*OnlyNamespace=*/true) ||
+      SS.isInvalid()) {
+    SkipUntil(tok::semi);
+    return nullptr;
+  }
+
+  if (SS.isNotEmpty())
+    Diag(SS.getBeginLoc(),
+         diag::err_concept_definition_not_identifier);
+
+  UnqualifiedId Result;
+  if (ParseUnqualifiedId(SS, /*EnteringContext=*/false,
+                         /*AllowDestructorName=*/false,
+                         /*AllowConstructorName=*/false,
+                         /*AllowDeductionGuide=*/false,
+                         /*ObjectType=*/ParsedType(), /*TemplateKWLoc=*/nullptr,
+                         Result)) {
+    SkipUntil(tok::semi);
+    return nullptr;
+  }
+
+  if (Result.getKind() != UnqualifiedIdKind::IK_Identifier) {
+    Diag(Result.getBeginLoc(), diag::err_concept_definition_not_identifier);
+    SkipUntil(tok::semi);
+    return nullptr;
+  }
+
+  IdentifierInfo *Id = Result.Identifier;
+  SourceLocation IdLoc = Result.getBeginLoc();
+
+  DiagnoseAndSkipCXX11Attributes();
+
+  if (!TryConsumeToken(tok::equal)) {
+    Diag(Tok.getLocation(), diag::err_expected) << tok::equal;
+    SkipUntil(tok::semi);
+    return nullptr;
+  }
+
+  ExprResult ConstraintExprResult =
+      Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression());
+  if (ConstraintExprResult.isInvalid()) {
+    SkipUntil(tok::semi);
+    return nullptr;
+  }
+
+  DeclEnd = Tok.getLocation();
+  ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
+  Expr *ConstraintExpr = ConstraintExprResult.get();
+  return Actions.ActOnConceptDefinition(getCurScope(),
+                                        *TemplateInfo.TemplateParams,
+                                        Id, IdLoc, ConstraintExpr);
+}
+
 /// ParseTemplateParameters - Parses a template-parameter-list enclosed in
 /// angle brackets. Depth is the depth of this template-parameter-list, which
 /// is the number of template headers directly enclosing this template header.
 /// TemplateParams is the current list of template parameters we're building.
 /// The template parameter we parse will be added to this list. LAngleLoc and
 /// RAngleLoc will receive the positions of the '<' and '>', respectively,
 /// that enclose this template parameter list.
 ///

lib/Sema/SemaDecl.cpp

Sema::getTemplateNameKindForDiagnostics(TemplateName Name) {
   if (isa<FunctionTemplateDecl>(TD))
     return TemplateNameKindForDiagnostics::FunctionTemplate;
   if (isa<VarTemplateDecl>(TD))
     return TemplateNameKindForDiagnostics::VarTemplate;
   if (isa<TypeAliasTemplateDecl>(TD))
     return TemplateNameKindForDiagnostics::AliasTemplate;
   if (isa<TemplateTemplateParmDecl>(TD))
     return TemplateNameKindForDiagnostics::TemplateTemplateParam;
+  if (isa<ConceptDecl>(TD))
+    return TemplateNameKindForDiagnostics::Concept;
   return TemplateNameKindForDiagnostics::DependentTemplate;
 }
 
 // Determines the context to return to after temporarily entering a
 // context.  This depends in an unnecessarily complicated way on the
 // exact ordering of callbacks from the parser.
 DeclContext *Sema::getContainingDC(DeclContext *DC) {
 

lib/Sema/SemaDeclCXX.cpp

if (isa<UsingShadowDecl>(Target)) {
     assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
   }
 
   NamedDecl *NonTemplateTarget = Target;
   if (auto *TargetTD = dyn_cast<TemplateDecl>(Target))
     NonTemplateTarget = TargetTD->getTemplatedDecl();
 
   UsingShadowDecl *Shadow;
-  if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
+  if (NonTemplateTarget && isa<CXXConstructorDecl>(NonTemplateTarget)) {
     bool IsVirtualBase =
         isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
                             UD->getQualifier()->getAsRecordDecl());
     Shadow = ConstructorUsingShadowDecl::Create(
         Context, CurContext, UD->getLocation(), UD, Orig, IsVirtualBase);
   } else {
     Shadow = UsingShadowDecl::Create(Context, CurContext, UD->getLocation(), UD,
                                      Target);

lib/Sema/SemaLookup.cpp

if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
   if (TagDecl *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D))
     return ID->getDefinition();
   if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D))
     return PD->getDefinition();
   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
-    return getDefinitionToImport(TD->getTemplatedDecl());
+    if (NamedDecl *TTD = TD->getTemplatedDecl())
+      return getDefinitionToImport(TTD);
   return nullptr;
 }
 
 void Sema::diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
                                  MissingImportKind MIK, bool Recover) {
   // Suggest importing a module providing the definition of this entity, if
   // possible.
   NamedDecl *Def = getDefinitionToImport(Decl);

lib/Sema/SemaTemplate.cpp

if (!D && ResultCount > 1) {
     if (isa<FunctionTemplateDecl>(TD)) {
       TemplateKind = TNK_Function_template;
 
       // We'll do this lookup again later.
       R.suppressDiagnostics();
     } else {
       assert(isa<ClassTemplateDecl>(TD) || isa<TemplateTemplateParmDecl>(TD) ||
              isa<TypeAliasTemplateDecl>(TD) || isa<VarTemplateDecl>(TD) ||
-             isa<BuiltinTemplateDecl>(TD));
+             isa<BuiltinTemplateDecl>(TD) || isa<ConceptDecl>(TD));
       TemplateKind =
-          isa<VarTemplateDecl>(TD) ? TNK_Var_template : TNK_Type_template;
+          isa<VarTemplateDecl>(TD) ? TNK_Var_template :
+          isa<ConceptDecl>(TD) ? TNK_Concept_template :
+          TNK_Type_template;
     }
   }
 
   TemplateResult = TemplateTy::make(Template);
   return TemplateKind;
 }
 
 bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
if (DTN && DTN->isIdentifier())
     // dependent name is substituted.
     return Context.getDependentTemplateSpecializationType(ETK_None,
                                                           DTN->getQualifier(),
                                                           DTN->getIdentifier(),
                                                           TemplateArgs);
 
   TemplateDecl *Template = Name.getAsTemplateDecl();
   if (!Template || isa<FunctionTemplateDecl>(Template) ||
-      isa<VarTemplateDecl>(Template)) {
+      isa<VarTemplateDecl>(Template) ||
+      isa<ConceptDecl>(Template)) {
     // We might have a substituted template template parameter pack. If so,
     // build a template specialization type for it.
     if (Name.getAsSubstTemplateTemplateParmPack())
       return Context.getTemplateSpecializationType(Name, TemplateArgs);
 
     Diag(TemplateLoc, diag::err_template_id_not_a_type)
       << Name;
     NoteAllFoundTemplates(Name);
void Sema::diagnoseMissingTemplateArguments(TemplateName Name,
                                             SourceLocation Loc) {
   Diag(Loc, diag::err_template_missing_args)
     << (int)getTemplateNameKindForDiagnostics(Name) << Name;
   if (TemplateDecl *TD = Name.getAsTemplateDecl()) {
     Diag(TD->getLocation(), diag::note_template_decl_here)
       << TD->getTemplateParameters()->getSourceRange();
   }
 }
 
+ExprResult
+Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
+                             const DeclarationNameInfo &NameInfo,
+                             ConceptDecl *Template,
+                             SourceLocation TemplateLoc,
+                             const TemplateArgumentListInfo *TemplateArgs) {
+  // TODO: Do concept specialization here.
+  Diag(NameInfo.getBeginLoc(), diag::err_concept_not_implemented) <<
+    "concept specialization";
+  return ExprError();
+}
+
 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      LookupResult &R,
                                      bool RequiresADL,
                                  const TemplateArgumentListInfo *TemplateArgs) {
   // FIXME: Can we do any checking at this point? I guess we could check the
   // template arguments that we have against the template name, if the template
   // name refers to a single template. That's not a terribly common case,
ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
   auto AnyDependentArguments = [&]() -> bool {
     bool InstantiationDependent;
     return TemplateArgs &&
            TemplateSpecializationType::anyDependentTemplateArguments(
                *TemplateArgs, InstantiationDependent);
   };
 
   // In C++1y, check variable template ids.
   if (R.getAsSingle<VarTemplateDecl>() && !AnyDependentArguments()) {
     return CheckVarTemplateId(SS, R.getLookupNameInfo(),
                               R.getAsSingle<VarTemplateDecl>(),
                               TemplateKWLoc, TemplateArgs);
   }
 
+  if (R.getAsSingle<ConceptDecl>() && !AnyDependentArguments()) {
+    return CheckConceptTemplateId(SS, R.getLookupNameInfo(),
+                                  R.getAsSingle<ConceptDecl>(),
+                                  TemplateKWLoc, TemplateArgs);
+  }
+
   // We don't want lookup warnings at this point.
   R.suppressDiagnostics();
 
   UnresolvedLookupExpr *ULE
     = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
                                    SS.getWithLocInContext(Context),
                                    TemplateKWLoc,
                                    R.getLookupNameInfo(),

 Decl *Sema::ActOnTemplateDeclarator(Scope *S,
                               MultiTemplateParamsArg TemplateParameterLists,
                                     Declarator &D) {
   Decl *NewDecl = HandleDeclarator(S, D, TemplateParameterLists);
   ActOnDocumentableDecl(NewDecl);
   return NewDecl;
 }
 
-/// Strips various properties off an implicit instantiation
+Decl *Sema::ActOnConceptDefinition(Scope *S,
+                              MultiTemplateParamsArg TemplateParameterLists,
+                                   IdentifierInfo *Name, SourceLocation NameLoc,
+                                   Expr *ConstraintExpr) {
+  DeclContext *DC = CurContext;
+
+  if (!DC->getRedeclContext()->isFileContext()) {
+    Diag(NameLoc,
+      diag::err_concept_decls_may_only_appear_in_global_namespace_scope);
+    return nullptr;
+  }
+
+  if (TemplateParameterLists.size() > 1) {
+    Diag(NameLoc, diag::err_concept_extra_headers);
+    return nullptr;
+  }
+
+  if (TemplateParameterLists.front()->size() == 0) {
+    Diag(NameLoc, diag::err_concept_no_parameters);
+    return nullptr;
+  }
+
+  ConceptDecl *NewDecl = ConceptDecl::Create(Context, DC, NameLoc, Name,
+                                             TemplateParameterLists.front(),
+                                             ConstraintExpr);
+
+  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.
+    // TODO: Make a test once we have actual associated constraints.
+    Diag(NameLoc, diag::err_concept_no_associated_constraints);
+    NewDecl->setInvalidDecl();
+  }
+
+  // Check for conflicting previous declaration.
+  DeclarationNameInfo NameInfo(NewDecl->getDeclName(), NameLoc);
+  LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
+                        ForVisibleRedeclaration);
+  LookupName(Previous, S);
+
+  FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage=*/false,
+                       /*AllowInlineNamespace*/false);
+  if (!Previous.empty()) {
+    auto *Old = Previous.getRepresentativeDecl();
+    Diag(NameLoc, isa<ConceptDecl>(Old) ? diag::err_redefinition :
+         diag::err_redefinition_different_kind) << NewDecl->getDeclName();
+    Diag(Old->getLocation(), diag::note_previous_definition);
+  }
+
+  ActOnDocumentableDecl(NewDecl);
+  PushOnScopeChains(NewDecl, S);
+  return NewDecl;
+}
+
+/// \brief Strips various properties off an implicit instantiation
 /// that has just been explicitly specialized.
 static void StripImplicitInstantiation(NamedDecl *D) {
   D->dropAttr<DLLImportAttr>();
   D->dropAttr<DLLExportAttr>();
 
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     FD->setInlineSpecified(false);
 }

lib/Sema/SemaTemplateInstantiateDecl.cpp

unsigned DiagID = SemaRef.getDiagnostics().getCustomDiagID(
                                                DiagnosticsEngine::Error,
                                                "cannot instantiate %0 yet");
   SemaRef.Diag(D->getLocation(), DiagID)
     << D->getDeclKindName();
 
   return nullptr;
 }
 
+Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
+  llvm_unreachable("Concept definitions cannot reside inside a template");
+}
+
 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/Serialization/ASTCommon.cpp

bool serialization::isRedeclarableDeclKind(unsigned Kind) {
   case Decl::OMPAllocate:
   case Decl::OMPRequires:
   case Decl::OMPCapturedExpr:
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
   case Decl::BuiltinTemplate:
   case Decl::Decomposition:
   case Decl::Binding:
+  case Decl::Concept:
     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/ASTReaderDecl.cpp

public:
     RedeclarableResult VisitVarDeclImpl(VarDecl *D);
     void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
     void VisitImplicitParamDecl(ImplicitParamDecl *PD);
     void VisitParmVarDecl(ParmVarDecl *PD);
     void VisitDecompositionDecl(DecompositionDecl *DD);
     void VisitBindingDecl(BindingDecl *BD);
     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
     DeclID VisitTemplateDecl(TemplateDecl *D);
+    void VisitConceptDecl(ConceptDecl *D);
     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
     void VisitClassTemplateDecl(ClassTemplateDecl *D);
     void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
     void VisitVarTemplateDecl(VarTemplateDecl *D);
     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
     void VisitUsingDecl(UsingDecl *D);
DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
   auto *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
   TemplateParameterList *TemplateParams = Record.readTemplateParameterList();
   // FIXME handle associated constraints
   D->init(TemplatedDecl, TemplateParams);
 
   return PatternID;
 }
 
+void ASTDeclReader::VisitConceptDecl(ConceptDecl *D) {
+  VisitTemplateDecl(D);
+  D->ConstraintExpr = Record.readExpr();
+  mergeMergeable(D);
+}
+
 ASTDeclReader::RedeclarableResult
 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
   RedeclarableResult Redecl = VisitRedeclarable(D);
 
   // Make sure we've allocated the Common pointer first. We do this before
   // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
   RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
   if (!CanonD->Common) {
case DECL_VAR_TEMPLATE:
     D = VarTemplateDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_VAR_TEMPLATE_SPECIALIZATION:
     D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
     D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_FUNCTION_TEMPLATE:
     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_TEMPLATE_TYPE_PARM:
     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
     break;
case DECL_TEMPLATE_TEMPLATE_PARM:
     break;
   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
                                                      Record.readInt());
     break;
   case DECL_TYPE_ALIAS_TEMPLATE:
     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
     break;
+  case DECL_CONCEPT:
+    D = ConceptDecl::CreateDeserialized(Context, ID);
+    break;
   case DECL_STATIC_ASSERT:
     D = StaticAssertDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_OBJC_METHOD:
     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_OBJC_INTERFACE:
     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);

lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);
   RECORD(DECL_VAR_TEMPLATE);
   RECORD(DECL_VAR_TEMPLATE_SPECIALIZATION);
   RECORD(DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION);
   RECORD(DECL_FUNCTION_TEMPLATE);
   RECORD(DECL_TEMPLATE_TYPE_PARM);
   RECORD(DECL_NON_TYPE_TEMPLATE_PARM);
   RECORD(DECL_TEMPLATE_TEMPLATE_PARM);
+  RECORD(DECL_CONCEPT);
   RECORD(DECL_TYPE_ALIAS_TEMPLATE);
   RECORD(DECL_STATIC_ASSERT);
   RECORD(DECL_CXX_BASE_SPECIFIERS);
   RECORD(DECL_CXX_CTOR_INITIALIZERS);
   RECORD(DECL_INDIRECTFIELD);
   RECORD(DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK);
   RECORD(DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK);
   RECORD(DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION);

lib/Serialization/ASTWriterDecl.cpp

public:
     void VisitIndirectFieldDecl(IndirectFieldDecl *D);
     void VisitVarDecl(VarDecl *D);
     void VisitImplicitParamDecl(ImplicitParamDecl *D);
     void VisitParmVarDecl(ParmVarDecl *D);
     void VisitDecompositionDecl(DecompositionDecl *D);
     void VisitBindingDecl(BindingDecl *D);
     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
     void VisitTemplateDecl(TemplateDecl *D);
+    void VisitConceptDecl(ConceptDecl *D);
     void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
     void VisitClassTemplateDecl(ClassTemplateDecl *D);
     void VisitVarTemplateDecl(VarTemplateDecl *D);
     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
     void VisitUsingDecl(UsingDecl *D);
     void VisitUsingPackDecl(UsingPackDecl *D);

 
 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
   VisitNamedDecl(D);
 
   Record.AddDeclRef(D->getTemplatedDecl());
   Record.AddTemplateParameterList(D->getTemplateParameters());
 }
 
+void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
+  VisitTemplateDecl(D);
+  Record.AddStmt(D->getConstraintExpr());
+  Code = serialization::DECL_CONCEPT;
+}
+
 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
   VisitRedeclarable(D);
 
   // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
   // getCommonPtr() can be used while this is still initializing.
   if (D->isFirstDecl()) {
     // This declaration owns the 'common' pointer, so serialize that data now.
     Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());

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

+// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+
+template<typename T> concept C = true;
+static_assert(C<int>); // expected-error{{sorry, unimplemented concepts feature concept specialization used}}

test/Parser/cxx-concept-declaration.cpp

-
-// Support parsing of concepts
-// Disabled for now.
-// expected-no-diagnostics
-
-// RUN:  %clang_cc1 -std=c++14 -fconcepts-ts -x c++ -verify %s
-// template<typename T> concept C1 = true;

test/Parser/cxx2a-concept-declaration.cpp

+// Support parsing of concepts
+
+// RUN:  %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+template<typename T> concept C1 = true; // expected-note 2{{previous}}
+
+template<typename T> concept C1 = true; // expected-error{{redefinition}}
+
+template<concept T> concept D1 = true;
+// expected-error@-1{{expected template parameter}}
+// expected-error@-2{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
+
+template<template<typename> concept T> concept D2 = true;
+// expected-error@-1{{expected identifier}}
+// expected-error@-2{{template template parameter requires 'class' after the parameter list}}
+// expected-error@-3{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
+
+template<typename T> concept C2 = 0.f; // expected-error {{constraint expression must be of type 'bool' but is of type 'float'}}
+
+struct S1 {
+  template<typename T> concept C1 = true; // expected-error {{concept declarations may only appear in global or namespace scope}}
+};
+
+extern "C++" {
+  template<typename T> concept C1 = true; // expected-error{{redefinition}}
+}
+
+template<typename A>
+template<typename B>
+concept C4 = true; // expected-error {{extraneous template parameter list in concept definition}}
+
+template<typename T> concept C5 = true; // expected-note {{previous}} expected-note {{previous}}
+int C5; // expected-error {{redefinition}}
+struct C5 {}; // expected-error {{redefinition}}
+
+struct C6 {}; // expected-note{{previous definition is here}}
+template<typename T> concept C6 = true;
+// expected-error@-1{{redefinition of 'C6' as different kind of symbol}}
+
+// TODO: Add test to prevent explicit specialization, partial specialization
+// and explicit instantiation of concepts.
+
+template<typename T, T v>
+struct integral_constant { static constexpr T value = v; };
+
+namespace N {
+  template<typename T> concept C7 = true;
+}
+using N::C7;
+
+template <bool word> concept C8 = integral_constant<bool, wor>::value;
+// expected-error@-1{{use of undeclared identifier 'wor'; did you mean 'word'?}}
+// expected-note@-2{{'word' declared here}}
+
+template<typename T> concept bool C9 = true;
+// expected-warning@-1{{ISO C++2a does not permit the 'bool' keyword after 'concept'}}
+
+template<> concept C10 = false;
+// expected-error@-1{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
+
+template<> concept C9<int> = false;
+// expected-error@-1{{name defined in concept definition must be an identifier}}
+
+template<typename T> concept N::C11 = false;
+// expected-error@-1{{name defined in concept definition must be an identifier}}
+
+class A { };
+// expected-note@-1{{'A' declared here}}
+
+template<typename T> concept A::C12 = false;
+// expected-error@-1{{expected namespace name}}
+
+template<typename T> concept operator int = false;
+// expected-error@-1{{name defined in concept definition must be an identifier}}

test/Parser/cxx2a-concepts-ambig-constraint-expr.cpp

 // RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ %s -verify
 
 // Test parsing of constraint-expressions in cases where the grammar is
 // ambiguous with the expectation that the longest token sequence which matches
 // the syntax is consumed without backtracking.
 
 // type-specifier-seq in conversion-type-id
 template <typename T> requires (bool)&T::operator short
 unsigned int foo(); // expected-error {{C++ requires a type specifier for all declarations}}
 
 // type-specifier-seq in new-type-id
 template <typename T> requires (bool)sizeof new (T::f()) short
 unsigned int bar(); // expected-error {{C++ requires a type specifier for all declarations}}
 
 template<typename T> requires (bool)sizeof new (T::f()) unsigned // expected-error {{'struct' cannot be signed or unsigned}}
 struct X { }; // expected-error {{'X' cannot be defined in a type specifier}}
 
 // C-style cast
 // of function call on function-style cast
 template <typename T> requires (bool(T()))
 T (*fp)(); // expected-error {{use of undeclared identifier 'fp'}}
 
 // function-style cast
 // as the callee in a function call
 struct A {
   static int t;
   template <typename T> requires bool(T())
   (A(T (&t))) { } // expected-error {{called object type 'bool' is not a function or function pointer}}
 };

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

 // RUN: %clang_cc1 -std=c++14 -fconcepts-ts -x c++ %s -verify
 // expected-no-diagnostics
 
 // Test parsing of the optional requires-clause in a template-declaration.
 
 template <typename T> requires true
 void foo() { }
 
 
 template <typename T> requires !0
 struct A {
   void foo();
   struct AA;
   enum E : int;
   static int x;
 
   template <typename> requires true
   void Mfoo();
 
   template <typename> requires true
   struct M;
 
   template <typename> requires true
   static int Mx;
 
   template <typename TT> requires true
   using MQ = M<TT>;
 };
 
 template <typename T> requires !0
 void A<T>::foo() { }
 
 template <typename T> requires !0
 struct A<T>::AA { };
 
 template <typename T> requires !0
 enum A<T>::E : int { E0 };
 
 template <typename T> requires !0
 int A<T>::x = 0;
 
 template <typename T> requires !0
 template <typename> requires true
 void A<T>::Mfoo() { }
 
 template <typename T> requires !0
 template <typename> requires true
 struct A<T>::M { };
 
 template <typename T> requires !0
 template <typename> requires true
 int A<T>::Mx = 0;
 
 
 template <typename T> requires true
 int x = 0;
 
 template <typename T> requires true
 using Q = A<T>;
 
 struct C {
   template <typename> requires true
   void Mfoo();
 
   template <typename> requires true
   struct M;
 
   template <typename> requires true
   static int Mx;
 
   template <typename T> requires true
   using MQ = M<T>;
 };
 
 template <typename> requires true
 void C::Mfoo() { }
 
 template <typename> requires true
 struct C::M { };
 
 template <typename> requires true
 int C::Mx = 0;

tools/libclang/CIndex.cpp

CXCursor clang_getCursorDefinition(CXCursor C) {
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
   case Decl::OMPRequires:
   case Decl::ObjCTypeParam:
   case Decl::BuiltinTemplate:
   case Decl::PragmaComment:
   case Decl::PragmaDetectMismatch:
   case Decl::UsingPack:
+  case Decl::Concept:
     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;