From ec3cb573f522cf6748eae8afa5b33f9b65c33d6e Mon Sep 17 00:00:00 2001 From: Hubert Tong Date: Thu, 25 Jun 2015 00:23:39 +0000 Subject: [PATCH] [Concepts] Parsing of requires-clause in template-declaration Summary: This change implements parse-only acceptance of the optional requires-clause in a template-declaration. Diagnostic testing is added for cases where the grammar is ambiguous with the expectation that the longest token sequence which matches the syntax of a constraint-expression is consumed without backtracking. Reviewers: faisalv, fraggamuffin, rsmith Reviewed By: rsmith Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10462 llvm-svn: 240611 --- clang/include/clang/Parse/Parser.h | 1 + clang/lib/Parse/ParseExpr.cpp | 18 ++++ clang/lib/Parse/ParseTemplate.cpp | 13 ++- .../cxx-concepts-ambig-constraint-expr.cpp | 29 +++++++ .../Parser/cxx-concepts-requires-clause.cpp | 82 +++++++++++++++++++ 5 files changed, 142 insertions(+), 1 deletion(-) create mode 100644 clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp create mode 100644 clang/test/Parser/cxx-concepts-requires-clause.cpp diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index cdae0e35bc8a..7b9f8afafb15 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -1331,6 +1331,7 @@ public: ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast); ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast); + ExprResult ParseConstraintExpression(); // Expr that doesn't include commas. ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast); diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp index da759c76522c..36a302e52e6e 100644 --- a/clang/lib/Parse/ParseExpr.cpp +++ b/clang/lib/Parse/ParseExpr.cpp @@ -205,6 +205,24 @@ ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast) { return Actions.ActOnConstantExpression(Res); } +/// \brief Parse a constraint-expression. +/// +/// \verbatim +/// constraint-expression: [Concepts TS temp.constr.decl p1] +/// logical-or-expression +/// \endverbatim +ExprResult Parser::ParseConstraintExpression() { + // FIXME: this may erroneously consume a function-body as the braced + // initializer list of a compound literal + // + // FIXME: this may erroneously consume a parenthesized rvalue reference + // declarator as a parenthesized address-of-label expression + ExprResult LHS(ParseCastExpression(/*isUnaryExpression=*/false)); + ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::LogicalOr)); + + return Res; +} + bool Parser::isNotExpressionStart() { tok::TokenKind K = Tok.getKind(); if (K == tok::l_brace || K == tok::r_brace || diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp index a8116785fdfd..2a9becbc8570 100644 --- a/clang/lib/Parse/ParseTemplate.cpp +++ b/clang/lib/Parse/ParseTemplate.cpp @@ -116,7 +116,7 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, SmallVector TemplateParams; if (ParseTemplateParameters(CurTemplateDepthTracker.getDepth(), TemplateParams, LAngleLoc, RAngleLoc)) { - // Skip until the semi-colon or a }. + // Skip until the semi-colon or a '}'. SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); TryConsumeToken(tok::semi); return nullptr; @@ -132,6 +132,17 @@ Parser::ParseTemplateDeclarationOrSpecialization(unsigned Context, if (!TemplateParams.empty()) { isSpecialization = false; ++CurTemplateDepthTracker; + + if (TryConsumeToken(tok::kw_requires)) { + ExprResult ER = + Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression()); + if (!ER.isUsable()) { + // Skip until the semi-colon or a '}'. + SkipUntil(tok::r_brace, StopAtSemi | StopBeforeMatch); + TryConsumeToken(tok::semi); + return nullptr; + } + } } else { LastParamListWasEmpty = true; } diff --git a/clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp b/clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp new file mode 100644 index 000000000000..12ab338a6b00 --- /dev/null +++ b/clang/test/Parser/cxx-concepts-ambig-constraint-expr.cpp @@ -0,0 +1,29 @@ +// 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 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 requires (bool)sizeof new (T::f()) short +unsigned int bar(); // expected-error {{C++ requires a type specifier for all declarations}} + +template 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 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 requires bool(T()) + (A(T (&t))) { } // expected-error {{called object type 'bool' is not a function or function pointer}} +}; diff --git a/clang/test/Parser/cxx-concepts-requires-clause.cpp b/clang/test/Parser/cxx-concepts-requires-clause.cpp new file mode 100644 index 000000000000..01893a94cbc9 --- /dev/null +++ b/clang/test/Parser/cxx-concepts-requires-clause.cpp @@ -0,0 +1,82 @@ +// 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 requires true +void foo() { } + + +template requires !0 +struct A { + void foo(); + struct AA; + enum E : int; + static int x; + + template requires true + void Mfoo(); + + template requires true + struct M; + + template requires true + static int Mx; + + template requires true + using MQ = M; +}; + +template requires !0 +void A::foo() { } + +template requires !0 +struct A::AA { }; + +template requires !0 +enum A::E : int { E0 }; + +template requires !0 +int A::x = 0; + +template requires !0 +template requires true +void A::Mfoo() { } + +template requires !0 +template requires true +struct A::M { }; + +template requires !0 +template requires true +int A::Mx = 0; + + +template requires true +int x = 0; + +template requires true +using Q = A; + +struct C { + template requires true + void Mfoo(); + + template requires true + struct M; + + template requires true + static int Mx; + + template requires true + using MQ = M; +}; + +template requires true +void C::Mfoo() { } + +template requires true +struct C::M { }; + +template requires true +int C::Mx = 0;