static bool classofKind(Kind K) { return K == VarTemplate; }
};
+/// \brief Represents a C++2a ([temp] p1) concept-definition.
+class ConceptDecl : public TemplateDecl {
+protected:
+ Expr *ConstraintExpr;
+
+ ConceptDecl(DeclContext *DC,
+ SourceLocation NameLoc, DeclarationName Name,
+ TemplateParameterList *Params,
+ Expr *ConstraintExpr)
+ : TemplateDecl(nullptr, Concept, DC, NameLoc, Name, Params),
+ ConstraintExpr(ConstraintExpr) {};
+public:
+ static ConceptDecl *Create(ASTContext &C, DeclContext *DC,
+ SourceLocation NameLoc, DeclarationName Name,
+ TemplateParameterList *Params,
+ Expr *ConstraintExpr);
+ static ConceptDecl *CreateDeserialized(ASTContext &C, unsigned ID);
+
+ Expr *getConstraintExpr() const {
+ return ConstraintExpr;
+ }
+
+ void setConstraintExpr(Expr *CE) {
+ ConstraintExpr = CE;
+ }
+
+ SourceRange getSourceRange() const override LLVM_READONLY {
+ return SourceRange(getTemplateParameters()->getTemplateLoc(),
+ getConstraintExpr()->getLocEnd());
+ }
+
+ // 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;
DEF_TRAVERSE_TMPL_DECL(Var)
DEF_TRAVERSE_TMPL_DECL(Function)
+DEF_TRAVERSE_DECL(ConceptDecl, {
+ TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
+ TRY_TO(TraverseStmt(D->getConstraintExpr()));
+ // FIXME: Traverse all the concept specializations (once we implement forming
+ // template-ids with them).
+})
+
DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
// D is the "T" in something like
// template <template <typename> class T> class container { };
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>;
"force_cuda_host_device begin">;
} // end of Parse Issue category.
+let CategoryName = "Concepts Issue" in {
+def err_concept_at_non_namespace_scope : Error<
+ "'concept' can only appear in namespace scope">;
+
+def err_concept_extra_headers : Error<
+ "extraneous template parameter list in concept definition">;
+def err_concept_unexpected_scope_spec : Error<
+ "invalid nested name specifier; concepts must be defined in their own namespace">;
+def err_concept_nontemplate : Error<"concept definition must be a template; "
+ "missing template parameter list">;
+def err_concept_specialized : Error<
+ "'concept' cannot be "
+ "%select{explicitly specialized|partially specialized}0">;
+def note_concept_specialized : Note<
+ "'concept' cannot be "
+ "%select{explicitly specialized|partially specialized}0">;
+}
+
let CategoryName = "Modules Issue" in {
def err_unexpected_module_decl : Error<
"module declaration can only appear at the top level">;
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<
+ "type of constraint expression must be 'bool' - not '%0'">;
+def err_concept_no_associated_constraints : Error<
+ "concept may not have associated constraints">;
+def err_concept_feature_unimplemented : Error<
+ "unimplemented concept feature: %0 (coming soon)">;
def err_template_different_associated_constraints : Error<
"associated constraints differ in template redeclaration">;
/// 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,
+ /// The name refers to a concept definition.
+ TNK_Concept_template
};
}
#endif
-
-
ParsedAttributesWithRange &Attrs);
DeclSpecContext
getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context);
- void ParseDeclarationSpecifiers(
+
+ /// \brief Parses declaration-specifiers upto a declarator or ';' emitting
+ /// diagnostics as necessary and storing parsed information within DS.
+ ///
+ /// Note: Asides from parsing the routine C/C++ decl-specifiers (which could
+ /// include entire class or enum definitions), this also parses a concept
+ /// definition and stores the appropriate AST representations (for
+ /// class/enum/concept declarations/definitions, decltype
+ /// expression-operands or types, where appropriate) within DS.
+ void ParseDeclarationSpecifiersOrConceptDefinition(
DeclSpec &DS,
const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
AccessSpecifier AS = AS_none,
SourceLocation &DeclEnd,
AccessSpecifier AS = AS_none);
+ /// \brief Parse a single template declaration that declares a concept [c++2a]
+ /// and store the AST node within DS.
+ void ParseConceptDefinition(SourceLocation ConceptLoc, DeclSpec &DS,
+ const ParsedTemplateInfo &TemplateInfo,
+ AccessSpecifier AS, DeclSpecContext DSC);
//===--------------------------------------------------------------------===//
// Modules
DeclGroupPtrTy ParseModuleDecl();
namespace clang {
class ASTContext;
class CXXRecordDecl;
+ class ConceptDecl;
class TypeLoc;
class LangOptions;
class IdentifierInfo;
unsigned location_size() const { return Builder.getBuffer().second; }
};
-/// \brief Captures information about "declaration specifiers".
+/// \brief Captures information about "decl-specifiers" and also concept
+/// definitions.
///
/// "Declaration specifiers" encompasses storage-class-specifiers,
-/// type-specifiers, type-qualifiers, and function-specifiers.
+/// type-specifiers, type-qualifiers, and function-specifiers. This includes
+/// class and enum definitions whose AST representations must be stored - same
+/// with the expression-operands of decltype.
class DeclSpec {
public:
/// \brief storage-class-specifier
unsigned Constexpr_specified : 1;
union {
+ // Valid if isTypeRep is true.
UnionParsedType TypeRep;
+ // If we parsed a concept, class, enum (etc.) defintion or elaborated type
+ // specifier, this stores the AST representation. This is valid if either
+ // isDeclRep or isConceptSpecified returns true.
Decl *DeclRep;
+ // If we parsed a typeof(e) or decltype(e) operator, this stores the
+ // expression 'e'. Valid if isExprRep is true.
Expr *ExprRep;
};
SourceLocation FS_forceinlineLoc;
SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
SourceLocation TQ_pipeLoc;
+
+ // Even though 'concept' is not a specifier, we handle it here. This allows us
+ // to reuse infrastructure for diagnosing attributes and invalid
+ // decl-specifiers.
+ SourceLocation ConceptLoc;
WrittenBuiltinSpecs writtenBS;
void SaveWrittenBuiltinSpecs();
bool isTypeSpecOwned() const { return TypeSpecOwned; }
bool isTypeRep() const { return isTypeRep((TST) TypeSpecType); }
bool isTypeSpecPipe() const { return TypeSpecPipe; }
-
+ bool isDeclRep() const {
+ return isDeclRep((TST)TypeSpecType);
+ }
+
ParsedType getRepAsType() const {
assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type");
return TypeRep;
assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl");
return DeclRep;
}
+ // This is a template that should only be instantiated with the type
+ // ConceptDecl. By making it a template we only require ConceptDecl to be a
+ // complete type where this function is called.
+ template<class ConceptDeclTy = ConceptDecl>
+ ConceptDeclTy *getRepAsConcept() const {
+ static_assert(std::is_same<ConceptDeclTy, ConceptDecl>::value,
+ "Must only be instantiated with ConceptDecl");
+ assert(isConceptSpecified() && "DeclSpec does not store a concept");
+
+ return cast_or_null<ConceptDeclTy>(DeclRep);
+ }
Expr *getRepAsExpr() const {
assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr");
return ExprRep;
assert(isDeclRep((TST) TypeSpecType));
DeclRep = Rep;
}
+ // This function can only be instantiated with ConceptDecl. We made it a
+ // template so that ConceptDecl only has to be defined where this is called.
+ template <class ConceptDeclTy = ConceptDecl>
+ void setConceptRep(ConceptDecl *Rep) {
+ static_assert(std::is_same<ConceptDeclTy, ConceptDecl>::value,
+ "Must only be instantiated with ConceptDecl");
+ assert(isConceptSpecified() && "DeclSpec does not store a concept");
+ assert(!DeclRep &&
+ "why is this not null? We expect this function to be called only "
+ "once, and usually right after DeclRep was set to null");
+ DeclRep = Rep;
+ }
+
void UpdateTypeRep(ParsedType Rep) {
assert(isTypeRep((TST) TypeSpecType));
TypeRep = Rep;
unsigned &DiagID);
bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
unsigned &DiagID);
+ bool setConceptSpec(SourceLocation Loc, const char *&PrevSpec,
+ unsigned &DiagID, const PrintingPolicy &P);
bool isFriendSpecified() const { return Friend_specified; }
SourceLocation getFriendSpecLoc() const { return FriendLoc; }
bool isConstexprSpecified() const { return Constexpr_specified; }
SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
+ bool isConceptSpecified() const { return ConceptLoc.isValid(); }
+ SourceLocation getConceptLoc() const { return ConceptLoc; }
void ClearConstexprSpec() {
Constexpr_specified = false;
ConstexprLoc = SourceLocation();
Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
RecordDecl *&AnonRecord);
+
Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
MultiTemplateParamsArg TemplateParams,
bool IsExplicitInstantiation,
SourceLocation TemplateLoc,
const TemplateArgumentListInfo *TemplateArgs);
+ ExprResult
+ CheckConceptTemplateId(const CXXScopeSpec &SS,
+ const DeclarationNameInfo &NameInfo,
+ ConceptDecl *Template,
+ SourceLocation TemplateLoc,
+ const TemplateArgumentListInfo *TemplateArgs);
+
ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
SourceLocation TemplateKWLoc,
LookupResult &R,
const TemplateArgument *Args,
unsigned NumArgs);
+ // Concepts
+ ConceptDecl *ActOnConceptDefinition(
+ Scope *S,
+ MultiTemplateParamsArg TemplateParameterLists,
+ IdentifierInfo *Name, SourceLocation NameLoc,
+ Expr *ConstraintExpr);
+
//===--------------------------------------------------------------------===//
// C++ Variadic Templates (C++0x [temp.variadic])
//===--------------------------------------------------------------------===//
/// \brief A TypeAliasTemplateDecl record.
DECL_TYPE_ALIAS_TEMPLATE,
+ /// \brief A ConceptDecl record.
+ DECL_CONCEPT,
+
/// \brief A StaticAssertDecl record.
DECL_STATIC_ASSERT,
bool DumpRefOnly);
template<typename TemplateDecl>
void VisitTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
+ void VisitConceptDecl(const ConceptDecl *D);
void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
void VisitClassTemplateDecl(const ClassTemplateDecl *D);
void VisitClassTemplateSpecializationDecl(
!D->isCanonicalDecl());
}
+void ASTDumper::VisitConceptDecl(const ConceptDecl *D) {
+ dumpName(D);
+ dumpTemplateParameters(D->getTemplateParameters());
+ dumpStmt(D->getConstraintExpr());
+}
+
void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
// FIXME: We don't add a declaration of a function template specialization
// to its context when it's explicitly instantiated, so dump explicit
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;
}
}
+//===----------------------------------------------------------------------===//
+// ConceptDecl Implementation
+//===----------------------------------------------------------------------===//
+ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
+ SourceLocation NameLoc, DeclarationName Name,
+ TemplateParameterList *Params,
+ Expr *ConstraintExpr) {
+ // TODO: Do we need this?
+ // AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
+ return new (C, DC) ConceptDecl(DC, NameLoc, 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
//===----------------------------------------------------------------------===//
case Decl::OMPThreadPrivate:
case Decl::OMPCapturedExpr:
case Decl::Empty:
+ case Decl::Concept:
// None of these decls require codegen support.
return;
case Decl::TypeAliasTemplate:
case Decl::Block:
case Decl::Empty:
+ case Decl::Concept:
break;
case Decl::Using: // using X; [C++]
if (CGDebugInfo *DI = getModuleDebugInfo())
ParsingDeclSpec DS(*this);
DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context);
- ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, DSContext);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS, ParsedTemplateInfo(),
+ AS_none, DSContext);
// If we had a free-standing type definition with a missing semicolon, we
// may get this far before the problem becomes obvious.
/// specifier-qualifier-list is a subset of declaration-specifiers. Just
/// parse declaration-specifiers and complain about extra stuff.
/// TODO: diagnose attribute-specifiers and alignment-specifiers.
- ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS, DSC);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS, ParsedTemplateInfo(), AS,
+ DSC);
// Validate declspec for type-name.
unsigned Specs = DS.getParsedSpecifiers();
// and call ParsedFreeStandingDeclSpec as appropriate.
DS.ClearTypeSpecType();
ParsedTemplateInfo NotATemplate;
- ParseDeclarationSpecifiers(DS, NotATemplate, AS, DSContext, LateAttrs);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS, NotATemplate, AS, DSContext,
+ LateAttrs);
return false;
}
-/// ParseDeclarationSpecifiers
+/// ParseDeclarationSpecifiersOrConceptDefinition
/// declaration-specifiers: [C99 6.7]
/// storage-class-specifier declaration-specifiers[opt]
/// type-specifier declaration-specifiers[opt]
/// [OpenCL] '__kernel'
/// 'friend': [C++ dcl.friend]
/// 'constexpr': [C++0x dcl.constexpr]
-void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
+/// [C++2a] 'concept'
+void Parser::ParseDeclarationSpecifiersOrConceptDefinition(DeclSpec &DS,
const ParsedTemplateInfo &TemplateInfo,
AccessSpecifier AS,
DeclSpecContext DSContext,
ConsumeToken();
ParseEnumSpecifier(Loc, DS, TemplateInfo, AS, DSContext);
continue;
-
+
+ case tok::kw_concept:
+ ConsumeToken();
+ ParseConceptDefinition(Loc, DS, TemplateInfo, AS, DSContext);
+ continue;
// cv-qualifier:
case tok::kw_const:
isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID,
// too much hassle.
DS.takeAttributesFrom(FirstArgAttrs);
- ParseDeclarationSpecifiers(DS);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS);
// Parse the declarator. This is "PrototypeContext" or
if (MalformedTypeSpec)
DS.SetTypeSpecError();
- ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DeclSpecContext::DSC_class,
- &CommonLateParsedAttrs);
+ ParseDeclarationSpecifiersOrConceptDefinition(
+ DS, TemplateInfo, AS, DeclSpecContext::DSC_class, &CommonLateParsedAttrs);
// Turn off colon protection that was set for declspec.
X.restore();
cStyleParamWarned = true;
}
DeclSpec DS(AttrFactory);
- ParseDeclarationSpecifiers(DS);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS);
// Parse the declarator.
Declarator ParmDecl(DS, DeclaratorContext::PrototypeContext);
ParseDeclarator(ParmDecl);
Scope::AtCatchScope);
if (Tok.isNot(tok::ellipsis)) {
DeclSpec DS(AttrFactory);
- ParseDeclarationSpecifiers(DS);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS);
Declarator ParmDecl(DS, DeclaratorContext::ObjCCatchContext);
ParseDeclarator(ParmDecl);
/// 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]
+/// 'export'[opt] 'template' '<' template-parameter-list '>'
+/// requires-clause[opt]
+///
/// explicit-specialization: [ C++ temp.expl.spec]
/// 'template' '<' '>' declaration
Decl *
unsigned NewFlags = getCurScope()->getFlags() & ~Scope::TemplateParamScope;
ParseScopeFlags TemplateScopeFlags(this, NewFlags, isSpecialization);
- // Parse the actual template declaration.
- return ParseSingleDeclarationAfterTemplate(Context,
- ParsedTemplateInfo(&ParamLists,
- isSpecialization,
- LastParamListWasEmpty),
- ParsingTemplateParams,
- DeclEnd, AS, AccessAttrs);
+ return ParseSingleDeclarationAfterTemplate(
+ Context,
+ ParsedTemplateInfo(&ParamLists, isSpecialization, LastParamListWasEmpty),
+ ParsingTemplateParams, DeclEnd, AS, AccessAttrs);
}
/// \brief Parse a single declaration that declares a template,
// the template parameters.
ParsingDeclSpec DS(*this, &DiagsFromTParams);
- ParseDeclarationSpecifiers(DS, TemplateInfo, AS,
+ ParseDeclarationSpecifiersOrConceptDefinition(DS, TemplateInfo, AS,
getDeclSpecContextFromDeclaratorContext(Context));
if (Tok.is(tok::semi)) {
return ThisDecl;
}
+
+void
+Parser::ParseConceptDefinition(SourceLocation ConceptLoc,\r
+ DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo,\r
+ AccessSpecifier AS, \r
+ DeclSpecContext DSC) {
+\r
+ \r
+ auto DiagnoseAttributes = [this] {\r
+ ParsedAttributesWithRange attrs(this->AttrFactory);\r
+ this->MaybeParseGNUAttributes(attrs);\r
+ this->MaybeParseCXX11Attributes(attrs);\r
+ this->MaybeParseMicrosoftDeclSpecs(attrs);
+ this->ProhibitAttributes(attrs);
+ };
+
+
+ // If attributes exist after 'concept' kw but before the concept name,
+ // prohibit them for now (if CWG approves attributes on concepts, this is
+ // likely where they will go...).
+ DiagnoseAttributes();
+
+ // Set the concept specifier at ConceptLoc within 'DS' along with emitting any
+ // incompatible decl-specifier diagnostics.
+ {
+ const char *PrevSpec = 0;
+ unsigned int DiagId = 0;
+ if (DS.setConceptSpec(ConceptLoc, PrevSpec, DiagId,
+ Actions.getASTContext().getPrintingPolicy())) {
+ Diag(ConceptLoc, DiagId) << PrevSpec;
+ }
+ Actions.DiagnoseFunctionSpecifiers(DS);
+ }
+
+ if (DSC != DeclSpecContext::DSC_top_level) {
+ Diag(ConceptLoc, diag::err_concept_at_non_namespace_scope);
+ // If we are not in a template parameter context, skip to a '}' or ';'. The
+ // error messages are better if we just ignore this within template
+ // parameter lists.
+ if (DSC != DeclSpecContext::DSC_template_param) {
+ SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
+ } else {
+ SkipUntil(llvm::makeArrayRef({tok::comma, tok::greater}),
+ StopAtSemi | StopBeforeMatch);
+ }
+ return;
+ }
+
+ // A scope-guard that (if an error occurs while parsing a concept) skips to
+ // the next semi or closing brace.
+ class SkipUntilSemiOrClosingBraceOnScopeExit {
+ Parser &P;
+ bool Disabled = false;
+
+ public:
+ SkipUntilSemiOrClosingBraceOnScopeExit(Parser &P)
+ : P(P) {}
+ void disable() { Disabled = true; }
+ ~SkipUntilSemiOrClosingBraceOnScopeExit() {
+ if (!Disabled) {
+ // Skip until the semi-colon or a '}'.
+ P.SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch);
+ }
+ }
+ } SkipUntilSemiOrClosingBraceOnScopeExit(*this);
+
+ if (TemplateInfo.Kind == ParsedTemplateInfo::NonTemplate) {
+ Diag(ConceptLoc, diag::err_concept_nontemplate);
+ return;
+ }
+
+ const TemplateParameterLists &ParamLists = *TemplateInfo.TemplateParams;
+
+
+ // More than one TPL wouldn't make sense here.
+ if (ParamLists.size() != 1) {
+ Diag(Tok.getLocation(), diag::err_concept_extra_headers);
+ return;
+ }
+ const TemplateParameterList *const TPL = ParamLists[0];
+
+ // Explicit specializations of concepts are not allowed.
+ if (TPL->getLAngleLoc().getLocWithOffset(1) == TPL->getRAngleLoc()) {
+ assert(!TPL->size() &&
+ "can not have template parameters within empty angle brackets!");
+ Diag(ConceptLoc, diag::err_concept_specialized) << 0;
+ return;
+ }
+ // Concepts can not be defined with nested name specifiers.
+ CXXScopeSpec SS;
+ if (ParseOptionalCXXScopeSpecifier(SS, nullptr,
+ /*EnteringContext=*/false) ||
+ SS.isNotEmpty()) {
+
+ if (SS.isNotEmpty())
+ Diag(Tok.getLocation(), diag::err_concept_unexpected_scope_spec);
+ return;
+ }
+ // An identifier (i.e. the concept-name) should follow 'concept'.
+ if (!Tok.is(tok::identifier)) {
+ Diag(Tok.getLocation(), diag::err_expected) << "concept name";
+ return;
+ }
+
+ IdentifierInfo *Id = Tok.getIdentifierInfo();
+ SourceLocation IdLoc = ConsumeToken();
+
+ // If attributes exist after the identifier, parse them and diagnose
+ DiagnoseAttributes();
+
+ if (!TryConsumeToken(tok::equal)) {
+ Diag(Tok.getLocation(), diag::err_expected) << "equal";
+ return;
+ }
+
+ ExprResult ConstraintExprResult = ParseConstraintExpression();
+ if (ConstraintExprResult.isInvalid()) {
+ Diag(Tok.getLocation(), diag::err_expected_expression)
+ << "constraint-expression";
+ return;
+ }
+
+ // We can try to create a valid concept decl node now, so disable the
+ // scope-guard.
+ SkipUntilSemiOrClosingBraceOnScopeExit.disable();
+
+ Expr *ConstraintExpr = ConstraintExprResult.get();
+ ConceptDecl *const ConDecl = Actions.ActOnConceptDefinition(
+ getCurScope(), *TemplateInfo.TemplateParams, Id, IdLoc, ConstraintExpr);
+ DS.setConceptRep(ConDecl);
+
+ if (Tok.isNot(tok::semi)) {
+
+ ExpectAndConsume(tok::semi, diag::err_expected_after, "concept");
+ // Push this token back into the preprocessor and change our current token
+ // to ';' so that the rest of the code recovers as though there were an
+ // ';' after the definition.
+ PP.EnterToken(Tok);
+ Tok.setKind(tok::semi);
+ }
+ return;
+}
+
/// 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.
// FIXME: The type should probably be restricted in some way... Not all
// declarators (parts of declarators?) are accepted for parameters.
DeclSpec DS(AttrFactory);
- ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none,
- DeclSpecContext::DSC_template_param);
+ ParseDeclarationSpecifiersOrConceptDefinition(
+ DS, ParsedTemplateInfo(), AS_none, DeclSpecContext::DSC_template_param);
// Parse this as a typename.
Declarator ParamDecl(DS, DeclaratorContext::TemplateParamContext);
case tok::kw_struct:
case tok::kw_union:
case tok::kw___interface:
+ case tok::kw_concept:
// enum-specifier
case tok::kw_enum:
// cv-qualifier
AccessSpecifier AS) {
MaybeParseMicrosoftAttributes(DS.getAttributes());
// Parse the common declaration-specifiers piece.
- ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS,
+ ParseDeclarationSpecifiersOrConceptDefinition(DS, ParsedTemplateInfo(), AS,
DeclSpecContext::DSC_top_level);
// If we had a free-standing type definition with a missing semicolon, we
// Parse the common declaration-specifiers piece.
DeclSpec DS(AttrFactory);
- ParseDeclarationSpecifiers(DS);
+ ParseDeclarationSpecifiersOrConceptDefinition(DS);
// C99 6.9.1p6: 'each declaration in the declaration list shall have at
// least one declarator'.
/// Actions.getTypeName will not be needed to be called again (e.g. getTypeName
/// will not be called twice, once to check whether we have a declaration
/// specifier, and another one to get the actual type inside
-/// ParseDeclarationSpecifiers).
+/// ParseDeclarationSpecifiersOrConceptDefinition).
///
/// This returns true if an error occurred.
///
return Res;
}
+
template <class T> static bool BadSpecifier(T TNew, T TPrev,
const char *&PrevSpec,
unsigned &DiagID,
}
llvm_unreachable("Unknown typespec!");
}
-
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
const PrintingPolicy &Policy) {
switch (T) {
return false;
}
+bool DeclSpec::setConceptSpec(const SourceLocation Loc, const char *&PrevSpec,
+ unsigned &DiagID, const PrintingPolicy &PP) {
+ assert(Loc.isValid() && "Loc must be valid, since it is used to identify "
+ "that this function was called before");
+ assert(!ConceptLoc.isValid() &&
+ "how is this called if concept was already encountered and triggered "
+ "ParseConceptDefinition which parses upto the semi-colon");
+
+ PrevSpec = nullptr;
+ if (TypeSpecType != TST_unspecified) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<TST>(TypeSpecType), PP);
+ ClearTypeSpecType();
+ }
+ if (TypeSpecSign != TSS_unspecified) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<TSS>(TypeSpecSign));
+ TypeSpecSign = TSS_unspecified;
+ }
+ if (TypeSpecWidth != TSW_unspecified) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<TSW>(TypeSpecWidth));
+ TypeSpecWidth = TSW_unspecified;
+ }
+ if (StorageClassSpec != SCS_unspecified) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<SCS>(StorageClassSpec));
+ ClearStorageClassSpecs();
+ }
+ if (ThreadStorageClassSpec != TSCS_unspecified) {
+ PrevSpec =
+ DeclSpec::getSpecifierName(static_cast<TSCS>(ThreadStorageClassSpec));
+ ClearStorageClassSpecs();
+ }
+ if (TypeSpecComplex != TSC_unspecified) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<TSC>(TypeSpecComplex));
+ TypeSpecComplex = TSC_unspecified;
+ }
+ if (getTypeQualifiers()) {
+ PrevSpec = DeclSpec::getSpecifierName(static_cast<TQ>(TypeQualifiers));
+ ClearTypeQualifiers();
+ }
+ if (isFriendSpecified()) {
+ PrevSpec = "friend";
+ Friend_specified = false;
+ FriendLoc = SourceLocation();
+ }
+ if (isConstexprSpecified()) {
+ PrevSpec = "constexpr";
+ Constexpr_specified = false;
+ ConstexprLoc = SourceLocation();
+ }
+ if (isInlineSpecified()) {
+ PrevSpec = "inline";
+ FS_inlineLoc = SourceLocation();
+ FS_inline_specified = false;
+ }
+
+ if (PrevSpec) {
+ DiagID = diag::err_invalid_decl_spec_combination;
+ }
+ // We set the concept location regardless of whether an error occurred.
+ DeclRep = nullptr;
+ ConceptLoc = Loc;
+ return PrevSpec; // If this is non-null, an error occurred.
+}
+
void DeclSpec::SaveWrittenBuiltinSpecs() {
writtenBS.Sign = getTypeSpecSign();
writtenBS.Width = getTypeSpecWidth();
// TODO: return "auto function" and other bad things based on the real type.
// 'data definition has no type or storage class'?
+
}
bool DeclSpec::isMissingDeclaratorOk() {
MultiTemplateParamsArg TemplateParams,
bool IsExplicitInstantiation,
RecordDecl *&AnonRecord) {
+
+ // We don't need to do any additional declspecifier checking on concept
+ // definitions since that should already have been done when the concept kw
+ // location was set within DS.
+ if (DS.isConceptSpecified()) return DS.getRepAsConcept();
+
Decl *TagD = nullptr;
TagDecl *Tag = nullptr;
if (DS.getTypeSpecType() == DeclSpec::TST_class ||
NonTemplateTarget = TargetTD->getTemplatedDecl();
UsingShadowDecl *Shadow;
- if (isa<CXXConstructorDecl>(NonTemplateTarget)) {
+ if (!isa<ConceptDecl>(Target) && isa<CXXConstructorDecl>(NonTemplateTarget)) {
bool IsVirtualBase =
isVirtualDirectBase(cast<CXXRecordDecl>(CurContext),
UD->getQualifier()->getAsRecordDecl());
} 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;
}
}
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())
/*FoundD=*/nullptr, TemplateArgs);
}
+ExprResult
+Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
+ const DeclarationNameInfo &NameInfo,
+ ConceptDecl *Template,
+ SourceLocation TemplateLoc,
+ const TemplateArgumentListInfo *TemplateArgs) {
+ // TODO: Do concept specialization here.
+ Diag(Template->getLocation(), diag::err_concept_feature_unimplemented)
+ << "can not form concept template-id";
+ return ExprError();
+}
+
ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
SourceLocation TemplateKWLoc,
LookupResult &R,
// In C++1y, check variable template ids.
bool InstantiationDependent;
- if (R.getAsSingle<VarTemplateDecl>() &&
- !TemplateSpecializationType::anyDependentTemplateArguments(
- *TemplateArgs, InstantiationDependent)) {
+ const bool DependentArguments =
+ TemplateSpecializationType::anyDependentTemplateArguments(
+ *TemplateArgs, InstantiationDependent);
+ if (R.getAsSingle<VarTemplateDecl>() && !DependentArguments) {
return CheckVarTemplateId(SS, R.getLookupNameInfo(),
R.getAsSingle<VarTemplateDecl>(),
TemplateKWLoc, TemplateArgs);
}
+ if (R.getAsSingle<ConceptDecl>() && !DependentArguments) {
+ return CheckConceptTemplateId(SS, R.getLookupNameInfo(),
+ R.getAsSingle<ConceptDecl>(),
+ TemplateKWLoc, TemplateArgs);
+ }
+
// We don't want lookup warnings at this point.
R.suppressDiagnostics();
return NewDecl;
}
+ConceptDecl *Sema::ActOnConceptDefinition(Scope *S,
+ MultiTemplateParamsArg TemplateParameterLists, IdentifierInfo *Name,
+ SourceLocation NameLoc, Expr *ConstraintExpr) {
+ // C++2a [temp.concept]p3:
+ // A concept-definition shall appear in the global scope or in a namespace
+ // scope.
+ assert(
+ CurContext->isFileContext() &&
+ "We check during parsing that 'concept's only occur at namespace scope");
+
+ // Forbid any prior declaration of this name within the current namespace.
+ LookupResult Previous(*this,
+ DeclarationNameInfo(DeclarationName(Name), NameLoc),
+ LookupOrdinaryName);
+ LookupName(Previous, S);
+ if (!Previous.empty()) {
+ const NamedDecl *PrevDecl = Previous.getRepresentativeDecl();
+ if (PrevDecl->getDeclContext()->Equals(CurContext)) {
+ if (Previous.isSingleResult() &&
+ isa<ConceptDecl>(Previous.getFoundDecl())) {
+ Diag(NameLoc, diag::err_redefinition) << Name;
+ } else {
+ Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
+ }
+ Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
+ return nullptr;
+ }
+ }
+
+ ConceptDecl *NewDecl = ConceptDecl::Create(Context, CurContext, NameLoc,
+ Name, TemplateParameterLists[0],
+ ConstraintExpr);
+
+ if (!NewDecl)
+ return nullptr;
+
+ 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();
+ }
+
+ assert((S->isTemplateParamScope() || !TemplateParameterLists[0]->size()) &&
+ "Not in template param scope?");
+ assert(S->getParent() && !S->getParent()->isTemplateParamScope() &&
+ "Parent scope should exist and not be template parameter.");
+
+ ActOnDocumentableDecl(NewDecl);
+ PushOnScopeChains(NewDecl, S->getParent(), /*AddToContext=*/true);
+
+ return NewDecl;
+}
+
/// \brief Strips various properties off an implicit instantiation
/// that has just been explicitly specialized.
static void StripImplicitInstantiation(NamedDecl *D) {
return nullptr;
}
+Decl *TemplateDeclInstantiator::VisitConceptDecl(ConceptDecl *D) {
+ llvm_unreachable("Concept definitions cannot reside inside a template");
+ return nullptr;
+}
+
Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
llvm_unreachable("Unexpected decl");
}
case Decl::BuiltinTemplate:
case Decl::Decomposition:
case Decl::Binding:
+ case Decl::Concept:
return false;
// These indirectly derive from Redeclarable<T> but are not actually
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);
return PatternID;
}
+void ASTDeclReader::VisitConceptDecl(ConceptDecl *D) {
+ VisitTemplateDecl(D);
+ D->setConstraintExpr(Record.readExpr());
+}
+
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
RedeclarableResult Redecl = VisitRedeclarable(D);
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;
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);
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);
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);
+++ /dev/null
-
-// 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;
--- /dev/null
+// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -verify %s
+// Support parsing of concepts
+
+concept X; //expected-error {{must be a template}}
+
+template<typename T> concept C1 = true; //expected-note{{declared here}} <-- previous declaration
+
+template<typename T> concept C1 = true; // expected-error {{redefinition of 'C1'}}
+
+template<concept T> concept D1 = true; // expected-error {{'concept' can only appear in namespace scope}} \
+ expected-error {{expected template parameter}}
+
+template<> concept X = true; // expected-error {{cannot be explicitly specialized}}
+
+namespace ns1 {
+template<> concept D1 = true; // expected-error {{cannot be explicitly specialized}}
+template<typename T> const concept C1 = true; //expected-error{{cannot combine with}}
+namespace ns12 {
+template<typename T> decltype(T{}) concept C2 = true; //expected-error{{cannot combine with}}
+template<typename T> bool concept C3 = true; //expected-error{{cannot combine with}}
+template<typename T> unsigned concept C4 = true; //expected-error{{cannot combine with}}
+template<typename T> short concept C5 = true; //expected-error{{cannot combine with}}
+template<typename T> typedef concept C6 = true; //expected-error{{cannot combine with}}
+}
+template<class> concept
+ const //expected-error{{expected concept name}}
+ C2 = true;
+
+void f() {
+ concept X; //expected-error{{'concept' can only appear in namespace scope}}
+}
+template<concept X, //expected-error{{'concept' can only appear in namespace scope}} \
+ expected-error {{expected template parameter}}
+ int J> void f();
+}
+
+template<class T>
+concept [[test]] X2 [[test2]] = T::value; //expected-error2{{attribute list cannot appear here}}
+
+namespace ns2 {
+template<class T>
+concept [[test]] X2 [[test2]] = T::value; //expected-error2{{attribute list cannot appear here}}
+
+}
+
+namespace ns3 {
+ template<typename T> concept C1 = true;
+
+ namespace ns1 {
+ using ns3::C1; //expected-note{{declared here}}
+ template<typename T> concept C1 = true; // expected-error {{redefinition of 'C1'}}
+ }
+
+}
+
+// TODO:
+// template<typename T> concept C2 = 0.f; // expected error {{constraint expression must be 'bool'}}
+
+struct S1 {
+ template<typename T> concept C1 = true; // expected-error {{can only appear in namespace scope}}
+};
+
+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{{declared here}} <-- previous declaration
+template<typename T> concept C6 = true; // expected-error {{redefinition of 'C6' as different kind of symbol}}
+
+namespace thing {};
+
+template<typename T> concept thing::C7 = true; // expected-error {{concepts must be defined in their own namespace}}
+
+
+namespace ns5 {
+}
+
+// TODO: Add test to prevent explicit specialization, partial specialization
+// and explicit instantiation of concepts.
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
projects / clang / commitdiff