Index: clang/include/clang/AST/ASTConcept.h =================================================================== --- clang/include/clang/AST/ASTConcept.h +++ clang/include/clang/AST/ASTConcept.h @@ -22,6 +22,7 @@ #include namespace clang { class ConceptDecl; +class ConceptSpecializationExpr; /// \brief The result of a constraint satisfaction check, containing the /// necessary information to diagnose an unsatisfied constraint. Index: clang/include/clang/AST/DeclCXX.h =================================================================== --- clang/include/clang/AST/DeclCXX.h +++ clang/include/clang/AST/DeclCXX.h @@ -1892,6 +1892,37 @@ static bool classofKind(Kind K) { return K == CXXDeductionGuide; } }; +/// \brief Represents the body of a requires-expression. +/// +/// This decl exists merely to serve as the DeclContext for the local +/// parameters of the requires expression as well as other declarations inside +/// it. +/// +/// \code +/// template requires requires (T t) { {t++} -> regular; } +/// \endcode +/// +/// In this example, a RequiresExpr object will be generated for the expression, +/// and a RequiresExprBodyDecl will be created to hold the parameter t and the +/// template argument list imposed by the compound requirement. +class RequiresExprBodyDecl : public Decl, public DeclContext { + RequiresExprBodyDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc) + : Decl(RequiresExprBody, DC, StartLoc), DeclContext(RequiresExprBody) {} + +public: + friend class ASTDeclReader; + friend class ASTDeclWriter; + + static RequiresExprBodyDecl *Create(ASTContext &C, DeclContext *DC, + SourceLocation StartLoc); + + static RequiresExprBodyDecl *CreateDeserialized(ASTContext &C, unsigned ID); + + // Implement isa/cast/dyncast/etc. + static bool classof(const Decl *D) { return classofKind(D->getKind()); } + static bool classofKind(Kind K) { return K == RequiresExprBody; } +}; + /// Represents a static or instance method of a struct/union/class. /// /// In the terminology of the C++ Standard, these are the (static and Index: clang/include/clang/AST/ExprCXX.h =================================================================== --- clang/include/clang/AST/ExprCXX.h +++ clang/include/clang/AST/ExprCXX.h @@ -4930,6 +4930,400 @@ } }; + +/// \brief A static requirement that can be used in a requires-expression to +/// check properties of types and expression. +class Requirement { +public: + // Note - simple and compound requirements are both represented by the same + // class (ExprRequirement). + enum RequirementKind { RK_Type, RK_Simple, RK_Compound, RK_Nested }; +private: + const RequirementKind Kind; + bool Dependent : 1; + bool ContainsUnexpandedParameterPack : 1; + bool Satisfied : 1; +public: + struct SubstitutionDiagnostic { + StringRef SubstitutedEntity; + SourceLocation DiagLoc; + StringRef DiagMessage; + }; + + Requirement(RequirementKind Kind, bool IsDependent, + bool ContainsUnexpandedParameterPack, bool IsSatisfied = true) : + Kind(Kind), Dependent(IsDependent), + ContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack), + Satisfied(IsSatisfied) {} + + RequirementKind getKind() const { return Kind; } + + bool isSatisfied() const { + assert(!Dependent && + "isSatisfied can only be called on non-dependent requirements."); + return Satisfied; + } + + void setSatisfied(bool IsSatisfied) { + assert(!Dependent && + "setSatisfied can only be called on non-dependent requirements."); + Satisfied = IsSatisfied; + } + + void setDependent(bool IsDependent) { Dependent = IsDependent; } + bool isDependent() const { return Dependent; } + + void setContainsUnexpandedParameterPack(bool Contains) { + ContainsUnexpandedParameterPack = Contains; + } + bool containsUnexpandedParameterPack() const { + return ContainsUnexpandedParameterPack; + } +}; + +/// \brief A requires-expression requirement which queries the existence of a +/// type name or type template specialization ('type' requirements). +class TypeRequirement : public Requirement { +public: + enum SatisfactionStatus { + SS_Dependent, + SS_SubstitutionFailure, + SS_Satisfied + }; +private: + llvm::PointerUnion Value; + SatisfactionStatus Status; +public: + friend class ASTStmtReader; + friend class ASTStmtWriter; + + /// \brief Construct a type requirement from a type. If the given type is not + /// dependent, this indicates that the type exists and the requirement will be + /// satisfied. Otherwise, the SubstitutionDiagnostic constructor is to be + /// used. + TypeRequirement(TypeSourceInfo *T); + + /// \brief Construct a type requirement when the nested name specifier is + /// invalid due to a bad substitution. The requirement is unsatisfied. + TypeRequirement(SubstitutionDiagnostic *Diagnostic) : + Requirement(RK_Type, false, false, false), Value(Diagnostic), + Status(SS_SubstitutionFailure) {} + + SatisfactionStatus getSatisfactionStatus() const { return Status; } + void setSatisfactionStatus(SatisfactionStatus Status) { + this->Status = Status; + } + + bool isSubstitutionFailure() const { + return Status == SS_SubstitutionFailure; + } + SubstitutionDiagnostic *getSubstitutionDiagnostic() const { + assert(Status == SS_SubstitutionFailure && + "Attempted to get substitution diagnostic when there has been no " + "substitution failure."); + return Value.get(); + } + + TypeSourceInfo *getType() const { + assert(!isSubstitutionFailure() && + "Attempted to get type when there has been a substitution failure."); + return Value.get(); + } + + static bool classof(const Requirement *R) { + return R->getKind() == RK_Type; + } +}; + +/// \brief A requires-expression requirement which queries the validity and +/// properties of an expression ('simple' and 'compound' requirements). +class ExprRequirement : public Requirement { +public: + enum SatisfactionStatus { + SS_Dependent, + SS_ExprSubstitutionFailure, + SS_NoexceptNotMet, + SS_TypeRequirementSubstitutionFailure, + SS_ConstraintsNotSatisfied, + SS_Satisfied + }; + class ReturnTypeRequirement { + llvm::PointerIntPair< + llvm::PointerUnion, + 2, int> + TypeConstraintInfo; + public: + friend class ASTStmtReader; + friend class ASTStmtWriter; + + /// \brief No return type requirement was specified. + ReturnTypeRequirement() : TypeConstraintInfo(nullptr, 0) {} + + /// \brief A return type requirement was specified but it was a + /// substitution failure. + ReturnTypeRequirement(SubstitutionDiagnostic *SubstDiag) : + TypeConstraintInfo(SubstDiag, 0) {} + + /// \brief A 'type constraint' style return type requirement. + /// \param TPL an invented template parameter list containing a single + /// type parameter with a type-constraint. + ReturnTypeRequirement(TemplateParameterList *TPL); + + bool isDependent() const { + return TypeConstraintInfo.getInt() & 1; + } + + bool containsUnexpandedParameterPack() const { + return TypeConstraintInfo.getInt() & 2; + } + + bool isEmpty() const { + return TypeConstraintInfo.getPointer().isNull(); + } + + bool isSubstitutionFailure() const { + return !isEmpty() && + TypeConstraintInfo.getPointer().is(); + } + + bool isTypeConstraint() const { + return !isEmpty() && + TypeConstraintInfo.getPointer().is(); + } + + SubstitutionDiagnostic *getSubstitutionDiagnostic() const { + assert(isSubstitutionFailure()); + return TypeConstraintInfo.getPointer().get(); + } + + const TypeConstraint *getTypeConstraint() const; + + TemplateParameterList *getTypeConstraintTemplateParameterList() const { + assert(isTypeConstraint()); + return TypeConstraintInfo.getPointer().get(); + } + }; +private: + llvm::PointerUnion Value; + SourceLocation NoexceptLoc; // May be empty if noexcept wasn't specified. + ReturnTypeRequirement TypeReq; + ConceptSpecializationExpr *SubstitutedConstraintExpr; + SatisfactionStatus Status; +public: + friend class ASTStmtReader; + friend class ASTStmtWriter; + + /// \brief Construct a compound requirement. + /// \param E the expression which is checked by this requirement. + /// \param IsSimple whether this was a simple requirement in source. + /// \param NoexceptLoc the location of the noexcept keyword, if it was + /// specified, otherwise an empty location. + /// \param Req the requirement for the type of the checked expression. + /// \param Status the satisfaction status of this requirement. + ExprRequirement( + Expr *E, bool IsSimple, SourceLocation NoexceptLoc, + ReturnTypeRequirement Req, SatisfactionStatus Status, + ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr); + + /// \brief Construct a compound requirement whose expression was a + /// substitution failure. The requirement is not satisfied. + /// \param E the diagnostic emitted while instantiating the original + /// expression. + /// \param IsSimple whether this was a simple requirement in source. + /// \param NoexceptLoc the location of the noexcept keyword, if it was + /// specified, otherwise an empty location. + /// \param Req the requirement for the type of the checked expression (omit + /// if no requirement was specified). + ExprRequirement(SubstitutionDiagnostic *E, bool IsSimple, + SourceLocation NoexceptLoc, ReturnTypeRequirement Req = {}); + + bool isSimple() const { return getKind() == RK_Simple; } + bool isCompound() const { return getKind() == RK_Compound; } + + bool hasNoexceptRequirement() const { return NoexceptLoc.isValid(); } + SourceLocation getNoexceptLoc() const { return NoexceptLoc; } + + SatisfactionStatus getSatisfactionStatus() const { return Status; } + + bool isExprSubstitutionFailure() const { + return Status == SS_ExprSubstitutionFailure; + } + + const ReturnTypeRequirement &getReturnTypeRequirement() const { + return TypeReq; + } + + ConceptSpecializationExpr * + getReturnTypeRequirementSubstitutedConstraintExpr() const { + assert(Status >= SS_TypeRequirementSubstitutionFailure); + return SubstitutedConstraintExpr; + } + + SubstitutionDiagnostic *getExprSubstitutionDiagnostic() const { + assert(isExprSubstitutionFailure() && + "Attempted to get expression substitution diagnostic when there has " + "been no expression substitution failure"); + return Value.get(); + } + + Expr *getExpr() const { + assert(!isExprSubstitutionFailure() && + "ExprRequirement has no expression because there has been a " + "substitution failure."); + return Value.get(); + } + + static bool classof(const Requirement *R) { + return R->getKind() == RK_Compound || R->getKind() == RK_Simple; + } +}; + +/// \brief A requires-expression requirement which is satisfied when a general +/// constraint expression is satisfied ('nested' requirements). +class NestedRequirement : public Requirement { + llvm::PointerUnion Value; + const ASTConstraintSatisfaction *Satisfaction = nullptr; + +public: + friend class ASTStmtReader; + friend class ASTStmtWriter; + + NestedRequirement(SubstitutionDiagnostic *SubstDiag) : + Requirement(RK_Nested, /*Dependent=*/false, + /*ContainsUnexpandedParameterPack*/false, + /*Satisfied=*/false), Value(SubstDiag) {} + + NestedRequirement(Expr *Constraint) : + Requirement(RK_Nested, /*Dependent=*/true, + Constraint->containsUnexpandedParameterPack()), + Value(Constraint) { + assert(Constraint->isInstantiationDependent() && + "Nested requirement with non-dependent constraint must be " + "constructed with a ConstraintSatisfaction object"); + } + + NestedRequirement(ASTContext &C, Expr *Constraint, + const ConstraintSatisfaction &Satisfaction) : + Requirement(RK_Nested, Constraint->isInstantiationDependent(), + Constraint->containsUnexpandedParameterPack(), + Satisfaction.IsSatisfied), + Value(Constraint), + Satisfaction(ASTConstraintSatisfaction::Create(C, Satisfaction)) {} + + bool isSubstitutionFailure() const { + return Value.is(); + } + SubstitutionDiagnostic *getSubstitutionDiagnostic() const { + assert(isSubstitutionFailure() && + "getSubstitutionDiagnostic() may not be called when there was no " + "substitution failure."); + return Value.get(); + } + + Expr *getConstraintExpr() const { + assert(!isSubstitutionFailure() && "getConstraintExpr() may not be called " + "on nested requirements with " + "substitution failures."); + return Value.get(); + } + + const ASTConstraintSatisfaction &getConstraintSatisfaction() const { + assert(!isSubstitutionFailure() && "getConstraintSatisfaction() may not be " + "called on nested requirements with " + "substitution failures."); + return *Satisfaction; + } + + static bool classof(const Requirement *R) { + return R->getKind() == RK_Nested; + } +}; + +/// C++2a [expr.prim.req]: +/// A requires-expression provides a concise way to express requirements on +/// template arguments. A requirement is one that can be checked by name +/// lookup (6.4) or by checking properties of types and expressions. +/// [...] +/// A requires-expression is a prvalue of type bool [...] +class RequiresExpr final : public Expr, + llvm::TrailingObjects { + friend TrailingObjects; + friend class ASTStmtReader; + + unsigned NumLocalParameters; + unsigned NumRequirements; + RequiresExprBodyDecl *Body; + SourceLocation RBraceLoc; + + unsigned numTrailingObjects(OverloadToken) const { + return NumLocalParameters; + } + + unsigned numTrailingObjects(OverloadToken) const { + return NumRequirements; + } + + RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation RBraceLoc); + RequiresExpr(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters, + unsigned NumRequirements); + +public: + static RequiresExpr * + Create(ASTContext &C, SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, ArrayRef LocalParameters, + ArrayRef Requirements, SourceLocation RBraceLoc); + static RequiresExpr * + Create(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters, + unsigned NumRequirements); + + ArrayRef getLocalParameters() const { + return {getTrailingObjects(), NumLocalParameters}; + } + + RequiresExprBodyDecl *getBody() const { return Body; } + + ArrayRef getRequirements() const { + return {getTrailingObjects(), NumRequirements}; + } + + /// \brief Whether or not the requires clause is satisfied. + /// The expression must not be dependent. + bool isSatisfied() const { + assert(!isValueDependent() + && "isSatisfied called on a dependent RequiresExpr"); + return RequiresExprBits.IsSatisfied; + } + + SourceLocation getRequiresKWLoc() const { + return RequiresExprBits.RequiresKWLoc; + } + + SourceLocation getRBraceLoc() const { return RBraceLoc; } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == RequiresExprClass; + } + + SourceLocation getBeginLoc() const LLVM_READONLY { + return RequiresExprBits.RequiresKWLoc; + } + SourceLocation getEndLoc() const LLVM_READONLY { + return RBraceLoc; + } + + // Iterators + child_range children() { + return child_range(child_iterator(), child_iterator()); + } + const_child_range children() const { + return const_child_range(const_child_iterator(), const_child_iterator()); + } +}; + } // namespace clang #endif // LLVM_CLANG_AST_EXPRCXX_H Index: clang/include/clang/AST/RecursiveASTVisitor.h =================================================================== --- clang/include/clang/AST/RecursiveASTVisitor.h +++ clang/include/clang/AST/RecursiveASTVisitor.h @@ -2136,6 +2136,8 @@ TRY_TO(TraverseStmt(D->getDefaultArg())); }) +DEF_TRAVERSE_DECL(RequiresExprBodyDecl, {}) + #undef DEF_TRAVERSE_DECL // ----------------- Stmt traversal ----------------- @@ -2697,6 +2699,28 @@ S->getTemplateArgsAsWritten()->NumTemplateArgs)); }) +DEF_TRAVERSE_STMT(RequiresExpr, { + TRY_TO(TraverseDecl(S->getBody())); + for (ParmVarDecl *Parm : S->getLocalParameters()) + TRY_TO(TraverseDecl(Parm)); + for (Requirement *Req : S->getRequirements()) + if (auto *TypeReq = dyn_cast(Req)) { + if (!TypeReq->isSubstitutionFailure()) + TRY_TO(TraverseTypeLoc(TypeReq->getType()->getTypeLoc())); + } else if (auto *ExprReq = dyn_cast(Req)) { + if (!ExprReq->isExprSubstitutionFailure()) + TRY_TO(TraverseStmt(ExprReq->getExpr())); + auto &RetReq = ExprReq->getReturnTypeRequirement(); + if (RetReq.isTypeConstraint()) + TRY_TO(TraverseTemplateParameterListHelper( + RetReq.getTypeConstraintTemplateParameterList())); + } else { + auto *NestedReq = cast(Req); + if (!NestedReq->isSubstitutionFailure()) + TRY_TO(TraverseStmt(NestedReq->getConstraintExpr())); + } +}) + // These literals (all of them) do not need any action. DEF_TRAVERSE_STMT(IntegerLiteral, {}) DEF_TRAVERSE_STMT(FixedPointLiteral, {}) Index: clang/include/clang/AST/Stmt.h =================================================================== --- clang/include/clang/AST/Stmt.h +++ clang/include/clang/AST/Stmt.h @@ -910,6 +910,17 @@ SourceLocation NameLoc; }; + class RequiresExprBitfields { + friend class ASTStmtReader; + friend class ASTStmtWriter; + friend class RequiresExpr; + + unsigned : NumExprBits; + + unsigned IsSatisfied : 1; + SourceLocation RequiresKWLoc; + }; + //===--- C++ Coroutines TS bitfields classes ---===// class CoawaitExprBitfields { @@ -1008,6 +1019,7 @@ UnresolvedMemberExprBitfields UnresolvedMemberExprBits; CXXNoexceptExprBitfields CXXNoexceptExprBits; SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits; + RequiresExprBitfields RequiresExprBits; // C++ Coroutines TS expressions CoawaitExprBitfields CoawaitBits; Index: clang/include/clang/Basic/DeclNodes.td =================================================================== --- clang/include/clang/Basic/DeclNodes.td +++ clang/include/clang/Basic/DeclNodes.td @@ -100,5 +100,6 @@ def OMPAllocate : DeclNode; def OMPRequires : DeclNode; def Empty : DeclNode; +def RequiresExprBody : DeclNode, DeclContext; def LifetimeExtendedTemporary : DeclNode; Index: clang/include/clang/Basic/DiagnosticParseKinds.td =================================================================== --- clang/include/clang/Basic/DiagnosticParseKinds.td +++ clang/include/clang/Basic/DiagnosticParseKinds.td @@ -745,6 +745,33 @@ def err_explicit_instantiation_enum : Error< "enumerations cannot be explicitly instantiated">; def err_expected_template_parameter : Error<"expected template parameter">; +def note_ill_formed_requires_expression_outside_template : Note< + "requires expression outside a template declaration may not contain invalid " + "types or expressions">; +def err_empty_requires_expr : Error< + "a requires expression must contain at least one requirement">; +def err_requires_expr_parameter_list_ellipsis : Error< + "varargs not allowed in requires expression">; +def err_requires_expr_type_req_illegal_identifier : Error< + "expected identifier or template-id in type requirement">; +def err_requires_expr_type_req_template_args_on_non_template : Error< + "template arguments provided for non-template '%0'">; +def err_expected_semi_requirement : Error< + "expected ';' at end of requirement">; +def err_requires_expr_missing_arrow : Error< + "expected '->' before expression type requirement">; +def err_requires_expr_expected_type_constraint : Error< + "expected concept name with optional arguments">; +def err_requires_expr_simple_requirement_noexcept : Error< + "'noexcept' can only be used in a compound requirements (with '{' '}' around " + "the expression)">; +def err_requires_expr_simple_requirement_unexpected_tok : Error< + "unexpected %0 after expression; did you intend to use a compound " + "requirement (with '{' '}' around the expression)?">; +def warn_requires_expr_in_simple_requirement : Warning< + "this requires expression will only be checked for syntactic validity; did " + "you intend to place it in a nested requirement (add another 'requires' " + "before the expression)">, InGroup>; def err_missing_dependent_template_keyword : Error< "use 'template' keyword to treat '%0' as a dependent template name">; Index: clang/include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- clang/include/clang/Basic/DiagnosticSemaKinds.td +++ clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -2102,7 +2102,11 @@ "|in template argument|in typedef|in type alias|in function return type" "|in conversion function type|here|in lambda parameter" "|in type allocated by 'new'|in K&R-style function parameter" - "|in template parameter|in friend declaration}1">; + "|in template parameter|in friend declaration" + "|in requires expression parameter}1">; +def err_auto_not_allowed_in_return_type_requirement : Error< + "%select{'auto'|'decltype(auto)'|'__auto_type'}0 not allowed in expression " + "type requirement">; def err_dependent_deduced_tst : Error< "typename specifier refers to " "%select{class template|function template|variable template|alias template|" @@ -2590,17 +2594,54 @@ def note_substituted_constraint_expr_is_ill_formed : Note< "because substituted constraint expression is ill-formed%0">; def note_atomic_constraint_evaluated_to_false : Note< - "%select{and |because }0'%1' evaluated to false">; + "%select{and|because}0 '%1' evaluated to false">; def note_concept_specialization_constraint_evaluated_to_false : Note< - "%select{and |because }0'%1' evaluated to false">; + "%select{and|because}0 '%1' evaluated to false">; def note_single_arg_concept_specialization_constraint_evaluated_to_false : Note< - "%select{and |because }0%1 does not satisfy %2">; + "%select{and|because}0 %1 does not satisfy %2">; def note_atomic_constraint_evaluated_to_false_elaborated : Note< - "%select{and |because }0'%1' (%2 %3 %4) evaluated to false">; + "%select{and|because}0 '%1' (%2 %3 %4) evaluated to false">; def err_constrained_virtual_method : Error< "virtual function cannot have a requires clause">; def err_reference_to_function_with_unsatisfied_constraints : Error< "invalid reference to function %0: constraints not satisfied">; +def note_requires_expr_ill_formed_expr : Note< + "expression is invalid: %0">; +def note_requires_expr_no_implicit_conversion : Note< + "no implicit conversion exists between expression type %0 and expected type " + "%1">; +def err_requires_expr_local_parameter_default_argument : Error< + "default arguments not allowed for parameters of a requires expression">; +def err_requires_expr_parameter_referenced_in_evaluated_context : Error< + "constraint variable %0 cannot be used in an evaluated context">; +def note_expr_requirement_expr_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid: %2">; +def note_expr_requirement_expr_unknown_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid">; +def note_expr_requirement_noexcept_not_met : Note< + "%select{and|because}0 '%1' may throw an exception">; +def note_expr_requirement_type_requirement_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid: %2">; +def note_expr_requirement_type_requirement_unknown_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid">; +def note_expr_requirement_constraints_not_satisfied : Note< + "%select{and|because}0 type constraint '%1' was not satisfied:">; +def note_expr_requirement_constraints_not_satisfied_simple : Note< + "%select{and|because}0 %1 does not satisfy %2:">; +def note_type_requirement_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid: %2">; +def note_type_requirement_unknown_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid">; +def err_type_requirement_non_type_template : Error< + "'%0' refers to a %select{class template|function template|" + "variable template|alias template|template template parameter|template}1 " + "and not a type template">; +def err_type_requirement_no_such_type : Error< + "'%0' does not name a type">; +def note_nested_requirement_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid: %2">; +def note_nested_requirement_unknown_substitution_error : Note< + "%select{and|because}0 '%1' would be invalid">; def note_ambiguous_atomic_constraints : Note< "similar constraint expressions not considered equivalent; constraint " "expressions cannot be considered equivalent unless they originate from the " @@ -4582,6 +4623,8 @@ "in instantiation of template type alias %0 requested here">; def note_template_exception_spec_instantiation_here : Note< "in instantiation of exception specification for %0 requested here">; +def note_template_requirement_instantiation_here : Note< + "in instantiation of requirement here">; def warn_var_template_missing : Warning<"instantiation of variable %q0 " "required here, but no definition is available">, InGroup; @@ -4617,6 +4660,8 @@ "while checking a default template argument used here">; def note_concept_specialization_here : Note< "while checking the satisfaction of concept '%0' requested here">; +def note_nested_requirement_here : Note< + "while checking the satisfaction of nested requirement requested here">; def note_checking_constraints_for_template_id_here : Note< "while checking constraint satisfaction for template '%0' required here">; def note_checking_constraints_for_var_spec_id_here : Note< Index: clang/include/clang/Basic/StmtNodes.td =================================================================== --- clang/include/clang/Basic/StmtNodes.td +++ clang/include/clang/Basic/StmtNodes.td @@ -164,6 +164,7 @@ // C++2a Concepts expressions def ConceptSpecializationExpr : StmtNode; +def RequiresExpr : StmtNode; // Obj-C Expressions. def ObjCStringLiteral : StmtNode; Index: clang/include/clang/Parse/Parser.h =================================================================== --- clang/include/clang/Parse/Parser.h +++ clang/include/clang/Parse/Parser.h @@ -801,9 +801,10 @@ public: // If NeedType is true, then TryAnnotateTypeOrScopeToken will try harder to // find a type name by attempting typo correction. - bool TryAnnotateTypeOrScopeToken(); - bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, - bool IsNewScope); + bool TryAnnotateTypeOrScopeToken(bool ClassTemplateDeductionContext = true); + bool TryAnnotateTypeOrScopeTokenAfterScopeSpec( + CXXScopeSpec &SS, bool IsNewScope, + bool ClassTemplateDeductionContext = true); bool TryAnnotateCXXScopeToken(bool EnteringContext = false); private: @@ -1899,6 +1900,7 @@ //===--------------------------------------------------------------------===// // C++ Concepts + ExprResult ParseRequiresExpression(); void ParseTrailingRequiresClause(Declarator &D); //===--------------------------------------------------------------------===// @@ -2732,7 +2734,7 @@ Declarator &D, SmallVectorImpl &ParamInfo); void ParseParameterDeclarationClause( - Declarator &D, + DeclaratorContext DeclaratorContext, ParsedAttributes &attrs, SmallVectorImpl &ParamInfo, SourceLocation &EllipsisLoc); Index: clang/include/clang/Sema/DeclSpec.h =================================================================== --- clang/include/clang/Sema/DeclSpec.h +++ clang/include/clang/Sema/DeclSpec.h @@ -1757,7 +1757,8 @@ TemplateArgContext, // Any template argument (in template argument list). TemplateTypeArgContext, // Template type argument (in default argument). AliasDeclContext, // C++11 alias-declaration. - AliasTemplateContext // C++11 alias-declaration template. + AliasTemplateContext, // C++11 alias-declaration template. + RequiresExprContext // C++2a requires-expression. }; @@ -1981,6 +1982,7 @@ case DeclaratorContext::TemplateTypeArgContext: case DeclaratorContext::TrailingReturnContext: case DeclaratorContext::TrailingReturnVarContext: + case DeclaratorContext::RequiresExprContext: return true; } llvm_unreachable("unknown context kind!"); @@ -2003,6 +2005,7 @@ case DeclaratorContext::TemplateParamContext: case DeclaratorContext::CXXCatchContext: case DeclaratorContext::ObjCCatchContext: + case DeclaratorContext::RequiresExprContext: return true; case DeclaratorContext::TypeNameContext: @@ -2039,6 +2042,7 @@ case DeclaratorContext::MemberContext: case DeclaratorContext::PrototypeContext: case DeclaratorContext::TemplateParamContext: + case DeclaratorContext::RequiresExprContext: // Maybe one day... return false; @@ -2116,6 +2120,7 @@ case DeclaratorContext::TemplateArgContext: case DeclaratorContext::TemplateTypeArgContext: case DeclaratorContext::TrailingReturnContext: + case DeclaratorContext::RequiresExprContext: return false; } llvm_unreachable("unknown context kind!"); @@ -2337,6 +2342,7 @@ case DeclaratorContext::TemplateTypeArgContext: case DeclaratorContext::TrailingReturnContext: case DeclaratorContext::TrailingReturnVarContext: + case DeclaratorContext::RequiresExprContext: return false; } llvm_unreachable("unknown context kind!"); @@ -2370,6 +2376,7 @@ case DeclaratorContext::TrailingReturnContext: case DeclaratorContext::TrailingReturnVarContext: case DeclaratorContext::TemplateTypeArgContext: + case DeclaratorContext::RequiresExprContext: return false; case DeclaratorContext::BlockContext: Index: clang/include/clang/Sema/Sema.h =================================================================== --- clang/include/clang/Sema/Sema.h +++ clang/include/clang/Sema/Sema.h @@ -6279,13 +6279,17 @@ /// \brief Emit diagnostics explaining why a constraint expression was deemed /// unsatisfied. + /// \param First whether this is the first time an unsatisfied constraint is + /// diagnosed for this error. void - DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction); + DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction, + bool First = true); /// \brief Emit diagnostics explaining why a constraint expression was deemed /// unsatisfied. void - DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction& Satisfaction); + DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction& Satisfaction, + bool First = true); /// \brief Emit diagnostics explaining why a constraint expression was deemed /// unsatisfied because it was ill-formed. @@ -7279,11 +7283,47 @@ const TemplateArgument *Args, unsigned NumArgs); - // Concepts + //===--------------------------------------------------------------------===// + // C++ Concepts + //===--------------------------------------------------------------------===// Decl *ActOnConceptDefinition( Scope *S, MultiTemplateParamsArg TemplateParameterLists, IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr); + RequiresExprBodyDecl * + ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc, + ArrayRef LocalParameters, + Scope *BodyScope); + void ActOnExitRequiresExpr(); + Requirement *ActOnSimpleRequirement(Expr *E); + Requirement *ActOnTypeRequirement(SourceLocation TypenameKWLoc, + QualType Type); + Requirement *ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc); + Requirement *ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc, + TemplateIdAnnotation *TypeConstraint, + unsigned Depth); + Requirement *ActOnNestedRequirement(Expr *Constraint); + ExprRequirement * + BuildExprRequirement( + Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); + ExprRequirement * + BuildExprRequirement( + Requirement::SubstitutionDiagnostic *ExprSubstDiag, bool IsSatisfied, + SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement); + TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type); + TypeRequirement * + BuildTypeRequirement(Requirement::SubstitutionDiagnostic *SubstDiag); + NestedRequirement *BuildNestedRequirement(Expr *E); + NestedRequirement * + BuildNestedRequirement(Requirement::SubstitutionDiagnostic *SubstDiag); + ExprResult CreateRequiresExpr(SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation ClosingBraceLoc); + //===--------------------------------------------------------------------===// // C++ Variadic Templates (C++0x [temp.variadic]) //===--------------------------------------------------------------------===// @@ -7930,6 +7970,13 @@ /// template which was deferred until it was needed. ExceptionSpecInstantiation, + /// We are instantiating a requirement of a requires expression. + RequirementInstantiation, + + /// We are checking the satisfaction of a nested requirement of a requires + /// expression. + NestedRequirementConstraintsCheck, + /// We are declaring an implicit special member function. DeclaringSpecialMember, @@ -8251,6 +8298,19 @@ ParameterMappingSubstitution, NamedDecl *Template, SourceRange InstantiationRange); + /// \brief Note that we are substituting template arguments into a part of + /// a requirement of a requires expression. + InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, + Requirement *Req, + sema::TemplateDeductionInfo &DeductionInfo, + SourceRange InstantiationRange = SourceRange()); + + /// \brief Note that we are checking the satisfaction of the constraint + /// expression inside of a nested requirement. + InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation, + NestedRequirement *Req, ConstraintsCheck, + SourceRange InstantiationRange = SourceRange()); + /// Note that we have finished instantiating this template. void Clear(); Index: clang/include/clang/Sema/SemaConcept.h =================================================================== --- clang/include/clang/Sema/SemaConcept.h +++ clang/include/clang/Sema/SemaConcept.h @@ -13,10 +13,17 @@ #ifndef LLVM_CLANG_SEMA_SEMACONCEPT_H #define LLVM_CLANG_SEMA_SEMACONCEPT_H +#include "clang/AST/ASTConcept.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Expr.h" +#include "clang/AST/DeclTemplate.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallVector.h" +#include +#include + namespace clang { class Sema; Index: clang/include/clang/Serialization/ASTBitCodes.h =================================================================== --- clang/include/clang/Serialization/ASTBitCodes.h +++ clang/include/clang/Serialization/ASTBitCodes.h @@ -1403,6 +1403,9 @@ /// An LifetimeExtendedTemporaryDecl record. DECL_LIFETIME_EXTENDED_TEMPORARY, + /// A RequiresExprBodyDecl record. + DECL_REQUIRES_EXPR_BODY, + /// An ObjCTypeParamDecl record. DECL_OBJC_TYPE_PARAM, @@ -1785,6 +1788,7 @@ EXPR_MATERIALIZE_TEMPORARY, // MaterializeTemporaryExpr EXPR_CXX_FOLD, // CXXFoldExpr EXPR_CONCEPT_SPECIALIZATION,// ConceptSpecializationExpr + EXPR_REQUIRES, // RequiresExpr // CUDA EXPR_CUDA_KERNEL_CALL, // CUDAKernelCallExpr Index: clang/lib/AST/DeclBase.cpp =================================================================== --- clang/lib/AST/DeclBase.cpp +++ clang/lib/AST/DeclBase.cpp @@ -804,6 +804,7 @@ case OMPCapturedExpr: case Empty: case LifetimeExtendedTemporary: + case RequiresExprBody: // Never looked up by name. return 0; } @@ -1177,6 +1178,7 @@ case Decl::Captured: case Decl::OMPDeclareReduction: case Decl::OMPDeclareMapper: + case Decl::RequiresExprBody: // There is only one DeclContext for these entities. return this; Index: clang/lib/AST/DeclCXX.cpp =================================================================== --- clang/lib/AST/DeclCXX.cpp +++ clang/lib/AST/DeclCXX.cpp @@ -1964,6 +1964,16 @@ QualType(), nullptr, SourceLocation()); } +RequiresExprBodyDecl *RequiresExprBodyDecl::Create( + ASTContext &C, DeclContext *DC, SourceLocation StartLoc) { + return new (C, DC) RequiresExprBodyDecl(C, DC, StartLoc); +} + +RequiresExprBodyDecl *RequiresExprBodyDecl::CreateDeserialized(ASTContext &C, + unsigned ID) { + return new (C, ID) RequiresExprBodyDecl(C, nullptr, SourceLocation()); +} + void CXXMethodDecl::anchor() {} bool CXXMethodDecl::isStatic() const { Index: clang/lib/AST/Expr.cpp =================================================================== --- clang/lib/AST/Expr.cpp +++ clang/lib/AST/Expr.cpp @@ -3457,6 +3457,7 @@ case OpaqueValueExprClass: case SourceLocExprClass: case ConceptSpecializationExprClass: + case RequiresExprClass: // These never have a side-effect. return false; Index: clang/lib/AST/ExprCXX.cpp =================================================================== --- clang/lib/AST/ExprCXX.cpp +++ clang/lib/AST/ExprCXX.cpp @@ -17,6 +17,7 @@ #include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" +#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/Expr.h" #include "clang/AST/LambdaCapture.h" @@ -1843,3 +1844,81 @@ NumTemplateArgs)); return new (Buffer) ConceptSpecializationExpr(Empty, NumTemplateArgs); } + +const TypeConstraint * +ExprRequirement::ReturnTypeRequirement::getTypeConstraint() const { + assert(isTypeConstraint()); + auto TPL = + TypeConstraintInfo.getPointer().get(); + return cast(TPL->getParam(0)) + ->getTypeConstraint(); +} + +RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation RBraceLoc) + : Expr(RequiresExprClass, C.BoolTy, VK_RValue, OK_Ordinary, + /*TD=*/false, /*VD=*/false, /*ID=*/false, + /*ContainsUnexpandedParameterPack=*/false), + NumLocalParameters(LocalParameters.size()), + NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) { + RequiresExprBits.IsSatisfied = false; + RequiresExprBits.RequiresKWLoc = RequiresKWLoc; + bool Dependent = false; + bool ContainsUnexpandedParameterPack = false; + for (ParmVarDecl *P : LocalParameters) { + Dependent |= P->getType()->isInstantiationDependentType(); + ContainsUnexpandedParameterPack |= + P->getType()->containsUnexpandedParameterPack(); + } + RequiresExprBits.IsSatisfied = true; + for (Requirement *R : Requirements) { + Dependent |= R->isDependent(); + ContainsUnexpandedParameterPack |= R->containsUnexpandedParameterPack(); + if (!Dependent) { + RequiresExprBits.IsSatisfied = R->isSatisfied(); + if (!RequiresExprBits.IsSatisfied) + break; + } + } + std::copy(LocalParameters.begin(), LocalParameters.end(), + getTrailingObjects()); + std::copy(Requirements.begin(), Requirements.end(), + getTrailingObjects()); + RequiresExprBits.IsSatisfied |= Dependent; + setValueDependent(Dependent); + setInstantiationDependent(Dependent); + setContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack); +} + +RequiresExpr::RequiresExpr(ASTContext &C, EmptyShell Empty, + unsigned NumLocalParameters, + unsigned NumRequirements) + : Expr(RequiresExprClass, Empty), NumLocalParameters(NumLocalParameters), + NumRequirements(NumRequirements) { } + +RequiresExpr * +RequiresExpr::Create(ASTContext &C, SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation RBraceLoc) { + void *Mem = + C.Allocate(totalSizeToAlloc( + LocalParameters.size(), Requirements.size()), + alignof(RequiresExpr)); + return new (Mem) RequiresExpr(C, RequiresKWLoc, Body, LocalParameters, + Requirements, RBraceLoc); +} + +RequiresExpr * +RequiresExpr::Create(ASTContext &C, EmptyShell Empty, + unsigned NumLocalParameters, unsigned NumRequirements) { + void *Mem = + C.Allocate(totalSizeToAlloc( + NumLocalParameters, NumRequirements), + alignof(RequiresExpr)); + return new (Mem) RequiresExpr(C, Empty, NumLocalParameters, NumRequirements); +} Index: clang/lib/AST/ExprClassification.cpp =================================================================== --- clang/lib/AST/ExprClassification.cpp +++ clang/lib/AST/ExprClassification.cpp @@ -193,6 +193,7 @@ case Expr::DesignatedInitUpdateExprClass: case Expr::SourceLocExprClass: case Expr::ConceptSpecializationExprClass: + case Expr::RequiresExprClass: return Cl::CL_PRValue; case Expr::ConstantExprClass: Index: clang/lib/AST/ExprConstant.cpp =================================================================== --- clang/lib/AST/ExprConstant.cpp +++ clang/lib/AST/ExprConstant.cpp @@ -9846,6 +9846,7 @@ bool VisitSizeOfPackExpr(const SizeOfPackExpr *E); bool VisitSourceLocExpr(const SourceLocExpr *E); bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E); + bool VisitRequiresExpr(const RequiresExpr *E); // FIXME: Missing: array subscript of vector, member of vector }; @@ -12371,6 +12372,9 @@ return Success(E->isSatisfied(), E); } +bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) { + return Success(E->isSatisfied(), E); +} bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { switch (E->getOpcode()) { @@ -14029,6 +14033,7 @@ case Expr::CXXScalarValueInitExprClass: case Expr::TypeTraitExprClass: case Expr::ConceptSpecializationExprClass: + case Expr::RequiresExprClass: case Expr::ArrayTypeTraitExprClass: case Expr::ExpressionTraitExprClass: case Expr::CXXNoexceptExprClass: Index: clang/lib/AST/ItaniumMangle.cpp =================================================================== --- clang/lib/AST/ItaniumMangle.cpp +++ clang/lib/AST/ItaniumMangle.cpp @@ -3668,6 +3668,7 @@ case Expr::ConvertVectorExprClass: case Expr::StmtExprClass: case Expr::TypeTraitExprClass: + case Expr::RequiresExprClass: case Expr::ArrayTypeTraitExprClass: case Expr::ExpressionTraitExprClass: case Expr::VAArgExprClass: Index: clang/lib/AST/StmtPrinter.cpp =================================================================== --- clang/lib/AST/StmtPrinter.cpp +++ clang/lib/AST/StmtPrinter.cpp @@ -2269,6 +2269,66 @@ Policy); } +void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) { + OS << "requires "; + auto LocalParameters = E->getLocalParameters(); + if (!LocalParameters.empty()) { + OS << "("; + for (ParmVarDecl *LocalParam : LocalParameters) { + PrintRawDecl(LocalParam); + if (LocalParam != LocalParameters.back()) + OS << ", "; + } + + OS << ") "; + } + OS << "{ "; + auto Requirements = E->getRequirements(); + for (Requirement *Req : Requirements) { + if (auto *TypeReq = dyn_cast(Req)) { + std::string Buf; + llvm::raw_string_ostream S(Buf); + if (TypeReq->isSubstitutionFailure()) + S << "<>"; + else + TypeReq->getType()->getType().print(S, Policy); + S.flush(); + if (Buf.find("typename ") != 0) + OS << "typename "; + OS << Buf; + } else if (auto *ExprReq = dyn_cast(Req)) { + if (ExprReq->isCompound()) + OS << "{ "; + if (ExprReq->isExprSubstitutionFailure()) + OS << "<>"; + else + PrintExpr(ExprReq->getExpr()); + if (ExprReq->isCompound()) { + OS << " }"; + if (ExprReq->getNoexceptLoc().isValid()) + OS << " noexcept"; + const auto &RetReq = ExprReq->getReturnTypeRequirement(); + if (!RetReq.isEmpty()) { + OS << " -> "; + if (RetReq.isSubstitutionFailure()) + OS << "<>"; + else if (RetReq.isTypeConstraint()) + RetReq.getTypeConstraint()->print(OS, Policy); + } + } + } else { + auto *NestedReq = cast(Req); + OS << "requires "; + if (NestedReq->isSubstitutionFailure()) + OS << "<>"; + else + PrintExpr(NestedReq->getConstraintExpr()); + } + OS << "; "; + } + OS << "}"; +} + // C++ Coroutines TS void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { Index: clang/lib/AST/StmtProfile.cpp =================================================================== --- clang/lib/AST/StmtProfile.cpp +++ clang/lib/AST/StmtProfile.cpp @@ -1340,6 +1340,49 @@ S->getTemplateArgsAsWritten()->NumTemplateArgs); } +void StmtProfiler::VisitRequiresExpr(const RequiresExpr *S) { + VisitExpr(S); + ID.AddInteger(S->getLocalParameters().size()); + for (ParmVarDecl *LocalParam : S->getLocalParameters()) + VisitDecl(LocalParam); + ID.AddInteger(S->getRequirements().size()); + for (Requirement *Req : S->getRequirements()) { + if (auto *TypeReq = dyn_cast(Req)) { + ID.AddInteger(Requirement::RK_Type); + ID.AddBoolean(TypeReq->isSubstitutionFailure()); + if (!TypeReq->isSubstitutionFailure()) + VisitType(TypeReq->getType()->getType()); + } else if (auto *ExprReq = dyn_cast(Req)) { + ID.AddInteger(Requirement::RK_Compound); + ID.AddBoolean(ExprReq->isExprSubstitutionFailure()); + if (!ExprReq->isExprSubstitutionFailure()) + Visit(ExprReq->getExpr()); + // C++2a [expr.prim.req.compound]p1 Example: + // [...] The compound-requirement in C1 requires that x++ is a valid + // expression. It is equivalent to the simple-requirement x++; [...] + // We therefore do not profile isSimple() here. + ID.AddBoolean(ExprReq->getNoexceptLoc().isValid()); + const ExprRequirement::ReturnTypeRequirement &RetReq = + ExprReq->getReturnTypeRequirement(); + if (RetReq.isEmpty()) { + ID.AddInteger(0); + } else if (RetReq.isTypeConstraint()) { + ID.AddInteger(1); + Visit(RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint()); + } else { + assert(RetReq.isSubstitutionFailure()); + ID.AddInteger(2); + } + } else { + ID.AddInteger(Requirement::RK_Nested); + auto *NestedReq = cast(Req); + ID.AddBoolean(NestedReq->isSubstitutionFailure()); + if (!NestedReq->isSubstitutionFailure()) + Visit(NestedReq->getConstraintExpr()); + } + } +} + static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, UnaryOperatorKind &UnaryOp, BinaryOperatorKind &BinaryOp) { Index: clang/lib/CodeGen/CGDecl.cpp =================================================================== --- clang/lib/CodeGen/CGDecl.cpp +++ clang/lib/CodeGen/CGDecl.cpp @@ -111,6 +111,7 @@ case Decl::Empty: case Decl::Concept: case Decl::LifetimeExtendedTemporary: + case Decl::RequiresExprBody: // None of these decls require codegen support. return; Index: clang/lib/CodeGen/CGExprScalar.cpp =================================================================== --- clang/lib/CodeGen/CGExprScalar.cpp +++ clang/lib/CodeGen/CGExprScalar.cpp @@ -679,6 +679,10 @@ return Builder.getInt1(E->isSatisfied()); } + Value *VisitRequiresExpr(const RequiresExpr *E) { + return Builder.getInt1(E->isSatisfied()); + } + Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue()); } Index: clang/lib/Frontend/FrontendActions.cpp =================================================================== --- clang/lib/Frontend/FrontendActions.cpp +++ clang/lib/Frontend/FrontendActions.cpp @@ -429,6 +429,10 @@ return "ConstraintNormalization"; case CodeSynthesisContext::ParameterMappingSubstitution: return "ParameterMappingSubstitution"; + case CodeSynthesisContext::RequirementInstantiation: + return "RequirementInstantiation"; + case CodeSynthesisContext::NestedRequirementConstraintsCheck: + return "NestedRequirementConstraintsCheck"; } return ""; } Index: clang/lib/Frontend/InitPreprocessor.cpp =================================================================== --- clang/lib/Frontend/InitPreprocessor.cpp +++ clang/lib/Frontend/InitPreprocessor.cpp @@ -385,6 +385,9 @@ else Builder.defineMacro("__cplusplus", "199711L"); + if (LangOpts.ConceptsTS) + Builder.defineMacro("__cpp_concepts", "201707L"); + // C++1z [cpp.predefined]p1: // An integer literal of type std::size_t whose value is the alignment // guaranteed by a call to operator new(std::size_t) Index: clang/lib/Parse/ParseDecl.cpp =================================================================== --- clang/lib/Parse/ParseDecl.cpp +++ clang/lib/Parse/ParseDecl.cpp @@ -6366,7 +6366,7 @@ ProhibitAttributes(FnAttrs); } else { if (Tok.isNot(tok::r_paren)) - ParseParameterDeclarationClause(D, FirstArgAttrs, ParamInfo, + ParseParameterDeclarationClause(D.getContext(), FirstArgAttrs, ParamInfo, EllipsisLoc); else if (RequiresArg) Diag(Tok, diag::err_argument_required_after_attribute); @@ -6584,9 +6584,9 @@ /// after the opening parenthesis. This function will not parse a K&R-style /// identifier list. /// -/// D is the declarator being parsed. If FirstArgAttrs is non-null, then the -/// caller parsed those arguments immediately after the open paren - they should -/// be considered to be part of the first parameter. +/// DeclContext is the context of the declarator being parsed. If FirstArgAttrs +/// is non-null, then the caller parsed those attributes immediately after the +/// open paren - they should be considered to be part of the first parameter. /// /// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will /// be the location of the ellipsis, if any was parsed. @@ -6612,7 +6612,7 @@ /// [C++11] attribute-specifier-seq parameter-declaration /// void Parser::ParseParameterDeclarationClause( - Declarator &D, + DeclaratorContext DeclaratorContext, ParsedAttributes &FirstArgAttrs, SmallVectorImpl &ParamInfo, SourceLocation &EllipsisLoc) { @@ -6661,9 +6661,11 @@ // "LambdaExprParameterContext", because we must accept either // 'declarator' or 'abstract-declarator' here. Declarator ParmDeclarator( - DS, D.getContext() == DeclaratorContext::LambdaExprContext - ? DeclaratorContext::LambdaExprParameterContext - : DeclaratorContext::PrototypeContext); + DS, DeclaratorContext == DeclaratorContext::RequiresExprContext + ? DeclaratorContext::RequiresExprContext + : DeclaratorContext == DeclaratorContext::LambdaExprContext + ? DeclaratorContext::LambdaExprParameterContext + : DeclaratorContext::PrototypeContext); ParseDeclarator(ParmDeclarator); // Parse GNU attributes, if present. @@ -6716,7 +6718,7 @@ SourceLocation EqualLoc = Tok.getLocation(); // Parse the default argument - if (D.getContext() == DeclaratorContext::MemberContext) { + if (DeclaratorContext == DeclaratorContext::MemberContext) { // If we're inside a class definition, cache the tokens // corresponding to the default argument. We'll actually parse // them when we see the end of the class definition. Index: clang/lib/Parse/ParseExpr.cpp =================================================================== --- clang/lib/Parse/ParseExpr.cpp +++ clang/lib/Parse/ParseExpr.cpp @@ -751,6 +751,7 @@ /// [C++11] user-defined-literal /// '(' expression ')' /// [C11] generic-selection +/// [C++2a] requires-expression /// '__func__' [C99 6.4.2.2] /// [GNU] '__FUNCTION__' /// [MS] '__FUNCDNAME__' @@ -1588,6 +1589,9 @@ return ExprError(); return ParseCXXDeleteExpression(false, Tok.getLocation()); + case tok::kw_requires: // [C++2a] requires-expression + return ParseRequiresExpression(); + case tok::kw_noexcept: { // [C++0x] 'noexcept' '(' expression ')' if (EnsureNotPrimary()) return ExprError(); Index: clang/lib/Parse/ParseExprCXX.cpp =================================================================== --- clang/lib/Parse/ParseExprCXX.cpp +++ clang/lib/Parse/ParseExprCXX.cpp @@ -11,7 +11,9 @@ //===----------------------------------------------------------------------===// #include "clang/Parse/Parser.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/Decl.h" #include "clang/AST/DeclTemplate.h" +#include "clang/AST/ExprCXX.h" #include "clang/Basic/PrettyStackTrace.h" #include "clang/Lex/LiteralSupport.h" #include "clang/Parse/ParseDiagnostic.h" @@ -1314,9 +1316,9 @@ Actions.RecordParsingTemplateParameterDepth( CurTemplateDepthTracker.getOriginalDepth()); - ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc); - - // For a generic lambda, each 'auto' within the parameter declaration + ParseParameterDeclarationClause(D.getContext(), Attr, ParamInfo, + EllipsisLoc); + // For a generic lambda, each 'auto' within the parameter declaration // clause creates a template type parameter, so increment the depth. // If we've parsed any explicit template parameters, then the depth will // have already been incremented. So we make sure that at most a single @@ -3274,6 +3276,313 @@ return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get()); } +/// ParseRequiresExpression - Parse a C++2a requires-expression. +/// C++2a [expr.prim.req]p1 +/// A requires-expression provides a concise way to express requirements on +/// template arguments. A requirement is one that can be checked by name +/// lookup (6.4) or by checking properties of types and expressions. +/// +/// requires-expression: +/// 'requires' requirement-parameter-list[opt] requirement-body +/// +/// requirement-parameter-list: +/// '(' parameter-declaration-clause[opt] ')' +/// +/// requirement-body: +/// '{' requirement-seq '}' +/// +/// requirement-seq: +/// requirement +/// requirement-seq requirement +/// +/// requirement: +/// simple-requirement +/// type-requirement +/// compound-requirement +/// nested-requirement +ExprResult Parser::ParseRequiresExpression() { + assert(Tok.is(tok::kw_requires) && "Expected 'requires' keyword"); + SourceLocation RequiresKWLoc = ConsumeToken(); // Consume 'requires' + + llvm::SmallVector LocalParameterDecls; + if (Tok.is(tok::l_paren)) { + // requirement parameter list is present. + ParseScope LocalParametersScope(this, Scope::FunctionPrototypeScope | + Scope::DeclScope); + BalancedDelimiterTracker Parens(*this, tok::l_paren); + Parens.consumeOpen(); + if (!Tok.is(tok::r_paren)) { + ParsedAttributes FirstArgAttrs(getAttrFactory()); + SourceLocation EllipsisLoc; + llvm::SmallVector LocalParameters; + DiagnosticErrorTrap Trap(Diags); + ParseParameterDeclarationClause(DeclaratorContext::RequiresExprContext, + FirstArgAttrs, LocalParameters, + EllipsisLoc); + if (EllipsisLoc.isValid()) + Diag(EllipsisLoc, diag::err_requires_expr_parameter_list_ellipsis); + for (auto &ParamInfo : LocalParameters) + LocalParameterDecls.push_back(cast(ParamInfo.Param)); + if (Trap.hasErrorOccurred()) + SkipUntil(tok::r_paren, StopBeforeMatch); + } + Parens.consumeClose(); + } + + BalancedDelimiterTracker Braces(*this, tok::l_brace); + if (Braces.expectAndConsume()) + return ExprError(); + + // Start of requirement list + llvm::SmallVector Requirements; + + // C++2a [expr.prim.req]p2 + // Expressions appearing within a requirement-body are unevaluated operands. + EnterExpressionEvaluationContext Ctx( + Actions, Sema::ExpressionEvaluationContext::Unevaluated); + + ParseScope BodyScope(this, Scope::DeclScope); + RequiresExprBodyDecl *Body = Actions.ActOnEnterRequiresExpr( + RequiresKWLoc, LocalParameterDecls, getCurScope()); + + if (Tok.is(tok::r_brace)) + // Grammar does not allow an empty body. + // requirement-body: + // { requirement-seq } + // requirement-seq: + // requirement + // requirement-seq requirement + Diag(Tok, diag::err_empty_requires_expr); + // Continue anyway and produce a requires expr with no requirements. + else { + while (!Tok.is(tok::r_brace)) { + switch (Tok.getKind()) { + case tok::l_brace: { + // Compound requirement + // C++ [expr.prim.req.compound] + // compound-requirement: + // '{' expression '}' 'noexcept'[opt] + // return-type-requirement[opt] ';' + // return-type-requirement: + // trailing-return-type + // '->' cv-qualifier-seq[opt] constrained-parameter + // cv-qualifier-seq[opt] abstract-declarator[opt] + BalancedDelimiterTracker ExprBraces(*this, tok::l_brace); + ExprBraces.consumeOpen(); + ExprResult Expression = + Actions.CorrectDelayedTyposInExpr(ParseExpression()); + if (!Expression.isUsable()) { + ExprBraces.skipToEnd(); + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + if (ExprBraces.consumeClose()) + ExprBraces.skipToEnd(); + + Requirement *Req = nullptr; + SourceLocation NoexceptLoc; + TryConsumeToken(tok::kw_noexcept, NoexceptLoc); + if (Tok.is(tok::semi)) { + Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc); + if (Req) + Requirements.push_back(Req); + break; + } + if (!TryConsumeToken(tok::arrow)) + // User probably forgot the arrow, remind him and try to continue + Diag(Tok, diag::err_requires_expr_missing_arrow) + << FixItHint::CreateInsertion(Tok.getLocation(), "->"); + // Try to parse a 'type-constraint' + CXXScopeSpec SS; + if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), + /*EnteringContext=*/false, + /*MayBePseudoDestructor=*/nullptr, + // If this is not a type-constraint, + // then this scope-spec is part of + // the typename of a non-type + // template parameter + /*IsTypename=*/true, + /*LastII=*/nullptr, + // We won't find concepts in + // non-namespaces anyway, so might as + // well parse this correctly for + // possible type names. + /*OnlyNamespace=*/false, + /*SuppressDiagnostic=*/true)) { + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + if (!TryAnnotateTypeConstraint(SS)) { + Diag(Tok, diag::err_requires_expr_expected_type_constraint); + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + + Req = Actions.ActOnCompoundRequirement(Expression.get(), NoexceptLoc, + takeTemplateIdAnnotation(Tok), + TemplateParameterDepth); + ConsumeAnnotationToken(); + if (Req) + Requirements.push_back(Req); + break; + } + default: { + bool PossibleRequiresExprInSimpleRequirement = false; + if (Tok.is(tok::kw_requires)) { + auto IsNestedRequirement = [&] { + RevertingTentativeParsingAction TPA(*this); + ConsumeToken(); // 'requires' + if (Tok.is(tok::l_brace)) + // This is a requires expression + // requires (T t) { + // requires { t++; }; + // ... ^ + // } + return false; + if (Tok.is(tok::l_paren)) { + // This might be the parameter list of a requires expression + ConsumeParen(); + auto Res = TryParseParameterDeclarationClause(); + if (Res != TPResult::False) { + // Skip to the closing parenthesis + unsigned Depth = 1; + while (Depth != 0) { + if (Tok.is(tok::l_paren)) + Depth++; + else if (Tok.is(tok::r_paren)) + Depth--; + ConsumeAnyToken(); + } + // requires (T t) { + // requires () ? + // ... ^ + // - OR - + // requires (int x) ? + // ... ^ + // } + if (Tok.is(tok::l_brace)) + // requires (...) { + // ^ - a requires expression as a + // simple-requirement. + return false; + } + } + return true; + }; + if (IsNestedRequirement()) { + ConsumeToken(); + // Nested requirement + // C++ [expr.prim.req.nested] + // nested-requirement: + // 'requires' constraint-expression ';' + ExprResult ConstraintExpr = + Actions.CorrectDelayedTyposInExpr(ParseConstraintExpression()); + if (ConstraintExpr.isInvalid() || !ConstraintExpr.isUsable()) { + SkipUntil(tok::semi, tok::r_brace, + SkipUntilFlags::StopBeforeMatch); + break; + } + if (auto *Req = + Actions.ActOnNestedRequirement(ConstraintExpr.get())) + Requirements.push_back(Req); + else { + SkipUntil(tok::semi, tok::r_brace, + SkipUntilFlags::StopBeforeMatch); + break; + } + break; + } else + PossibleRequiresExprInSimpleRequirement = true; + } else if (Tok.is(tok::kw_typename)) { + Token TypenameKW = Tok; + // We need to consume the typename to allow 'requires { typename a; }' + ConsumeToken(); + if (TryAnnotateTypeOrScopeToken()) { + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + if (Tok.is(tok::annot_cxxscope)) { + // The lack of typename might have prevented this from being + // annotated as a type earlier. + UnconsumeToken(TypenameKW); + if (TryAnnotateTypeOrScopeToken()) { + SkipUntil(tok::semi, tok::r_brace, + SkipUntilFlags::StopBeforeMatch); + break; + } + } + if (!Tok.is(tok::annot_typename) || + !NextToken().isOneOf(tok::l_brace, tok::l_paren)) { + TypeResult Type = ParseTypeName(); + if (Type.isInvalid()) { + SkipUntil(tok::semi, tok::r_brace, + SkipUntilFlags::StopBeforeMatch); + break; + } + + if (auto *Req = + Actions.ActOnTypeRequirement(TypenameKW.getLocation(), + Type.get().get())) + Requirements.push_back(Req); + break; + } + } + // Simple requirement + // C++ [expr.prim.req.simple] + // simple-requirement: + // expression ';' + SourceLocation StartLoc = Tok.getLocation(); + ExprResult Expression = + Actions.CorrectDelayedTyposInExpr(ParseExpression()); + if (!Expression.isUsable()) { + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + if (!Expression.isInvalid() && PossibleRequiresExprInSimpleRequirement) + Diag(StartLoc, diag::warn_requires_expr_in_simple_requirement) + << FixItHint::CreateInsertion(StartLoc, "requires"); + if (auto *Req = Actions.ActOnSimpleRequirement(Expression.get())) + Requirements.push_back(Req); + else { + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + if (!Tok.is(tok::semi) && !Tok.is(tok::r_brace)) { + // User may have tried to put some compound requirement stuff here + if (Tok.is(tok::kw_noexcept)) + Diag(Tok, diag::err_requires_expr_simple_requirement_noexcept) + << FixItHint::CreateInsertion(StartLoc, "{") + << FixItHint::CreateInsertion(Tok.getLocation(), "}"); + else + Diag(Tok, diag::err_requires_expr_simple_requirement_unexpected_tok) + << Tok.getKind() << FixItHint::CreateInsertion(StartLoc, "{") + << FixItHint::CreateInsertion(Tok.getLocation(), "}"); + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + break; + } + break; + } + } + if (ExpectAndConsumeSemi(diag::err_expected_semi_requirement)) { + SkipUntil(tok::semi, tok::r_brace, SkipUntilFlags::StopBeforeMatch); + TryConsumeToken(tok::semi); + break; + } + } + if (Requirements.empty()) { + // Don't emit an empty requires expr here to avoid confusing the user with + // other diagnostics quoting an empty requires expression he never wrote. + Braces.consumeClose(); + Actions.ActOnExitRequiresExpr(); + return ExprError(); + } + } + Braces.consumeClose(); + Actions.ActOnExitRequiresExpr(); + return Actions.CreateRequiresExpr(RequiresKWLoc, Body, LocalParameterDecls, + Requirements, Braces.getCloseLocation()); +} + static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) { switch (kind) { default: llvm_unreachable("Not a known type trait"); Index: clang/lib/Parse/Parser.cpp =================================================================== --- clang/lib/Parse/Parser.cpp +++ clang/lib/Parse/Parser.cpp @@ -1765,7 +1765,7 @@ /// /// Note that this routine emits an error if you call it with ::new or ::delete /// as the current tokens, so only call it in contexts where these are invalid. -bool Parser::TryAnnotateTypeOrScopeToken() { +bool Parser::TryAnnotateTypeOrScopeToken(bool ClassTemplateDeductionContext) { assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) || Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) || Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) || @@ -1782,7 +1782,7 @@ if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) { Token TypedefToken; PP.Lex(TypedefToken); - bool Result = TryAnnotateTypeOrScopeToken(); + bool Result = TryAnnotateTypeOrScopeToken(ClassTemplateDeductionContext); PP.EnterToken(Tok, /*IsReinject=*/true); Tok = TypedefToken; if (!Result) @@ -1807,7 +1807,8 @@ Tok.is(tok::annot_decltype)) { // Attempt to recover by skipping the invalid 'typename' if (Tok.is(tok::annot_decltype) || - (!TryAnnotateTypeOrScopeToken() && Tok.isAnnotation())) { + (!TryAnnotateTypeOrScopeToken(ClassTemplateDeductionContext) && + Tok.isAnnotation())) { unsigned DiagID = diag::err_expected_qualified_after_typename; // MS compatibility: MSVC permits using known types with typename. // e.g. "typedef typename T* pointer_type" @@ -1874,14 +1875,15 @@ if (ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext*/false)) return true; - return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation); + return TryAnnotateTypeOrScopeTokenAfterScopeSpec( + SS, !WasScopeAnnotation, ClassTemplateDeductionContext); } /// Try to annotate a type or scope token, having already parsed an /// optional scope specifier. \p IsNewScope should be \c true unless the scope /// specifier was extracted from an existing tok::annot_cxxscope annotation. -bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, - bool IsNewScope) { +bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec( + CXXScopeSpec &SS, bool IsNewScope, bool ClassTemplateDeductionContext) { if (Tok.is(tok::identifier)) { // Determine whether the identifier is a type name. if (ParsedType Ty = Actions.getTypeName( @@ -1889,7 +1891,7 @@ false, NextToken().is(tok::period), nullptr, /*IsCtorOrDtorName=*/false, /*NonTrivialTypeSourceInfo*/true, - /*IsClassTemplateDeductionContext*/true)) { + ClassTemplateDeductionContext)) { SourceLocation BeginLoc = Tok.getLocation(); if (SS.isNotEmpty()) // it was a C++ qualified type name. BeginLoc = SS.getBeginLoc(); Index: clang/lib/Sema/Sema.cpp =================================================================== --- clang/lib/Sema/Sema.cpp +++ clang/lib/Sema/Sema.cpp @@ -1261,7 +1261,8 @@ DeclContext *DC = CurContext; while (true) { - if (isa(DC) || isa(DC) || isa(DC)) { + if (isa(DC) || isa(DC) || isa(DC) || + isa(DC)) { DC = DC->getParent(); } else if (isa(DC) && cast(DC)->getOverloadedOperator() == OO_Call && Index: clang/lib/Sema/SemaConcept.cpp =================================================================== --- clang/lib/Sema/SemaConcept.cpp +++ clang/lib/Sema/SemaConcept.cpp @@ -15,8 +15,12 @@ #include "clang/Sema/Sema.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaDiagnostic.h" +#include "clang/AST/RecursiveASTVisitor.h" #include "clang/Sema/TemplateDeduction.h" #include "clang/Sema/Template.h" +#include "clang/Sema/Overload.h" +#include "clang/Sema/Initialization.h" +#include "clang/Sema/SemaInternal.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/RecursiveASTVisitor.h" #include "llvm/ADT/DenseMap.h" @@ -301,6 +305,114 @@ return false; } +static void diagnoseUnsatisfiedRequirement(Sema &S, ExprRequirement *Req, + bool First) { + assert(!Req->isSatisfied() + && "Diagnose() can only be used on an unsatisfied requirement"); + switch (Req->getSatisfactionStatus()) { + case ExprRequirement::SS_Dependent: + llvm_unreachable("Diagnosing a dependent requirement"); + break; + case ExprRequirement::SS_ExprSubstitutionFailure: { + auto *SubstDiag = Req->getExprSubstitutionDiagnostic(); + if (!SubstDiag->DiagMessage.empty()) + S.Diag(SubstDiag->DiagLoc, + diag::note_expr_requirement_expr_substitution_error) << (int)First + << SubstDiag->SubstitutedEntity + << SubstDiag->DiagMessage; + else + S.Diag(SubstDiag->DiagLoc, + diag::note_expr_requirement_expr_unknown_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity; + break; + } + case ExprRequirement::SS_NoexceptNotMet: + S.Diag(Req->getNoexceptLoc(), + diag::note_expr_requirement_noexcept_not_met) + << (int)First << Req->getExpr(); + break; + case ExprRequirement::SS_TypeRequirementSubstitutionFailure: { + auto *SubstDiag = + Req->getReturnTypeRequirement().getSubstitutionDiagnostic(); + if (!SubstDiag->DiagMessage.empty()) + S.Diag(SubstDiag->DiagLoc, + diag::note_expr_requirement_type_requirement_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity + << SubstDiag->DiagMessage; + else + S.Diag(SubstDiag->DiagLoc, + diag::note_expr_requirement_type_requirement_unknown_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity; + break; + } + case ExprRequirement::SS_ConstraintsNotSatisfied: { + ConceptSpecializationExpr *ConstraintExpr = + Req->getReturnTypeRequirementSubstitutedConstraintExpr(); + if (ConstraintExpr->getTemplateArgsAsWritten()->NumTemplateArgs == 1) + // A simple case - expr type is the type being constrained and the concept + // was not provided arguments. + S.Diag(ConstraintExpr->getBeginLoc(), + diag::note_expr_requirement_constraints_not_satisfied_simple) + << (int)First << S.BuildDecltypeType(Req->getExpr(), + Req->getExpr()->getBeginLoc()) + << ConstraintExpr->getNamedConcept(); + else + S.Diag(ConstraintExpr->getBeginLoc(), + diag::note_expr_requirement_constraints_not_satisfied) + << (int)First << ConstraintExpr; + S.DiagnoseUnsatisfiedConstraint(ConstraintExpr->getSatisfaction()); + break; + } + case ExprRequirement::SS_Satisfied: + llvm_unreachable("We checked this above"); + } +} + +static void diagnoseUnsatisfiedRequirement(Sema &S, TypeRequirement *Req, + bool First) { + assert(!Req->isSatisfied() + && "Diagnose() can only be used on an unsatisfied requirement"); + switch (Req->getSatisfactionStatus()) { + case TypeRequirement::SS_Dependent: + llvm_unreachable("Diagnosing a dependent requirement"); + return; + case TypeRequirement::SS_SubstitutionFailure: { + auto *SubstDiag = Req->getSubstitutionDiagnostic(); + if (!SubstDiag->DiagMessage.empty()) + S.Diag(SubstDiag->DiagLoc, + diag::note_type_requirement_substitution_error) << (int)First + << SubstDiag->SubstitutedEntity << SubstDiag->DiagMessage; + else + S.Diag(SubstDiag->DiagLoc, + diag::note_type_requirement_unknown_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity; + return; + } + default: + llvm_unreachable("Unknown satisfaction status"); + return; + } +} + +static void diagnoseUnsatisfiedRequirement(Sema &S, NestedRequirement *Req, + bool First) { + if (Req->isSubstitutionFailure()) { + auto *SubstDiag = Req->getSubstitutionDiagnostic(); + if (!SubstDiag->DiagMessage.empty()) + S.Diag(SubstDiag->DiagLoc, + diag::note_nested_requirement_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity + << SubstDiag->DiagMessage; + else + S.Diag(SubstDiag->DiagLoc, + diag::note_nested_requirement_unknown_substitution_error) + << (int)First << SubstDiag->SubstitutedEntity; + return; + } + S.DiagnoseUnsatisfiedConstraint(Req->getConstraintSatisfaction(), First); +} + + static void diagnoseWellFormedUnsatisfiedConstraintExpr(Sema &S, Expr *SubstExpr, bool First = true) { @@ -377,6 +489,19 @@ } S.DiagnoseUnsatisfiedConstraint(CSE->getSatisfaction()); return; + } else if (auto *RE = dyn_cast(SubstExpr)) { + for (Requirement *Req : RE->getRequirements()) + if (!Req->isDependent() && !Req->isSatisfied()) { + if (auto *E = dyn_cast(Req)) + diagnoseUnsatisfiedRequirement(S, E, First); + else if (auto *T = dyn_cast(Req)) + diagnoseUnsatisfiedRequirement(S, T, First); + else + diagnoseUnsatisfiedRequirement(S, cast(Req), + First); + break; + } + return; } S.Diag(SubstExpr->getSourceRange().getBegin(), @@ -399,11 +524,11 @@ Record.template get(), First); } -void Sema::DiagnoseUnsatisfiedConstraint( - const ConstraintSatisfaction& Satisfaction) { +void +Sema::DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction& Satisfaction, + bool First) { assert(!Satisfaction.IsSatisfied && "Attempted to diagnose a satisfied constraint"); - bool First = true; for (auto &Pair : Satisfaction.Details) { diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First); First = false; @@ -411,10 +536,10 @@ } void Sema::DiagnoseUnsatisfiedConstraint( - const ASTConstraintSatisfaction &Satisfaction) { + const ASTConstraintSatisfaction &Satisfaction, + bool First) { assert(!Satisfaction.IsSatisfied && "Attempted to diagnose a satisfied constraint"); - bool First = true; for (auto &Pair : Satisfaction) { diagnoseUnsatisfiedConstraintExpr(*this, Pair.first, Pair.second, First); First = false; @@ -773,3 +898,71 @@ << AmbiguousAtomic2->getSourceRange(); return true; } + +ExprRequirement::ExprRequirement( + Expr *E, bool IsSimple, SourceLocation NoexceptLoc, + ReturnTypeRequirement Req, SatisfactionStatus Status, + ConceptSpecializationExpr *SubstitutedConstraintExpr) : + Requirement(IsSimple ? RK_Simple : RK_Compound, Status == SS_Dependent, + Status == SS_Dependent && + (E->containsUnexpandedParameterPack() || + Req.containsUnexpandedParameterPack()), + Status == SS_Satisfied), Value(E), NoexceptLoc(NoexceptLoc), + TypeReq(Req), SubstitutedConstraintExpr(SubstitutedConstraintExpr), + Status(Status) { + assert((!IsSimple || (Req.isEmpty() && NoexceptLoc.isInvalid())) && + "Simple requirement must not have a return type requirement or a " + "noexcept specification"); + assert((Status > SS_TypeRequirementSubstitutionFailure && Req.isTypeConstraint()) == + (SubstitutedConstraintExpr != nullptr)); +} + +ExprRequirement::ExprRequirement(SubstitutionDiagnostic *ExprSubstDiag, + bool IsSimple, SourceLocation NoexceptLoc, + ReturnTypeRequirement Req) : + Requirement(IsSimple ? RK_Simple : RK_Compound, Req.isDependent(), + Req.containsUnexpandedParameterPack(), /*IsSatisfied=*/false), + Value(ExprSubstDiag), NoexceptLoc(NoexceptLoc), TypeReq(Req), + Status(SS_ExprSubstitutionFailure) { + assert((!IsSimple || (Req.isEmpty() && NoexceptLoc.isInvalid())) && + "Simple requirement must not have a return type requirement or a " + "noexcept specification"); +} + +ExprRequirement::ReturnTypeRequirement:: +ReturnTypeRequirement(TemplateParameterList *TPL) : + TypeConstraintInfo(TPL, 0) { + assert(TPL->size() == 1); + const TypeConstraint *TC = + cast(TPL->getParam(0))->getTypeConstraint(); + assert(TC && + "TPL must have a template type parameter with a type constraint"); + auto *Constraint = + cast_or_null( + TC->getImmediatelyDeclaredConstraint()); + bool ContainsUnexpandedParameterPack = + Constraint->containsUnexpandedParameterPack(); + bool Dependent = false; + if (Constraint->getTemplateArgsAsWritten()) { + for (auto &ArgLoc : + Constraint->getTemplateArgsAsWritten()->arguments().drop_front(1)) { + if (ArgLoc.getArgument().isDependent()) { + Dependent = true; + break; + } + } + } + TypeConstraintInfo.setInt((Dependent ? 1 : 0) | + (ContainsUnexpandedParameterPack ? 2 : 0)); +} + +TypeRequirement::TypeRequirement(TypeSourceInfo *T) : + Requirement(RK_Type, T->getType()->isDependentType(), + T->getType()->containsUnexpandedParameterPack(), + /*IsSatisfied=*/true // We reach this ctor with either dependent + // types (in which IsSatisfied doesn't + // matter) or with non-dependent type in + // which the existance of the type + // indicates satisfaction. + ), Value(T), + Status(T->getType()->isDependentType() ? SS_Dependent : SS_Satisfied) {} Index: clang/lib/Sema/SemaDecl.cpp =================================================================== --- clang/lib/Sema/SemaDecl.cpp +++ clang/lib/Sema/SemaDecl.cpp @@ -6464,6 +6464,8 @@ return true; if (DC->isRecord()) return false; + if (isa(DC)) + return false; llvm_unreachable("Unexpected context"); } Index: clang/lib/Sema/SemaExceptionSpec.cpp =================================================================== --- clang/lib/Sema/SemaExceptionSpec.cpp +++ clang/lib/Sema/SemaExceptionSpec.cpp @@ -1378,6 +1378,7 @@ case Expr::StringLiteralClass: case Expr::SourceLocExprClass: case Expr::ConceptSpecializationExprClass: + case Expr::RequiresExprClass: // These expressions can never throw. return CT_Cannot; Index: clang/lib/Sema/SemaExpr.cpp =================================================================== --- clang/lib/Sema/SemaExpr.cpp +++ clang/lib/Sema/SemaExpr.cpp @@ -350,6 +350,17 @@ } } + if (isa(D) && isa(D->getDeclContext()) && + !isUnevaluatedContext()) { + // C++ [expr.prim.req.nested] p3 + // A local parameter shall only appear as an unevaluated operand + // (Clause 8) within the constraint-expression. + Diag(Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context) + << D; + Diag(D->getLocation(), diag::note_entity_declared_at) << D; + return true; + } + return false; } @@ -1904,7 +1915,7 @@ bool RefersToCapturedVariable = isa(D) && NeedToCaptureVariable(cast(D), NameInfo.getLoc()); - + DeclRefExpr *E = DeclRefExpr::Create( Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty, VK, FoundD, TemplateArgs, getNonOdrUseReasonInCurrentContext(D)); Index: clang/lib/Sema/SemaExprCXX.cpp =================================================================== --- clang/lib/Sema/SemaExprCXX.cpp +++ clang/lib/Sema/SemaExprCXX.cpp @@ -11,6 +11,7 @@ /// //===----------------------------------------------------------------------===// +#include "clang/Sema/Template.h" #include "clang/Sema/SemaInternal.h" #include "TreeTransform.h" #include "TypeLocBuilder.h" @@ -8111,3 +8112,198 @@ return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo); } + +Requirement *Sema::ActOnSimpleRequirement(Expr *E) { + return BuildExprRequirement(E, /*IsSimple=*/true, + /*NoexceptLoc=*/SourceLocation(), + /*ReturnTypeRequirement=*/{}); +} + +Requirement *Sema::ActOnTypeRequirement(SourceLocation TypenameKWLoc, + QualType Type) { + auto *LIT = dyn_cast(Type.getTypePtr()); + return BuildTypeRequirement( + LIT ? LIT->getTypeSourceInfo() : + Context.getTrivialTypeSourceInfo(Type, TypenameKWLoc)); +} + +Requirement *Sema::ActOnCompoundRequirement(Expr *E, + SourceLocation NoexceptLoc) { + return BuildExprRequirement(E, /*IsSimple=*/false, NoexceptLoc, + /*ReturnTypeRequirement=*/{}); +} + +Requirement * +Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc, + TemplateIdAnnotation *TypeConstraint, + unsigned Depth) { + // C++2a [expr.prim.req.compound] p1.3.3 + // [..] the expression is deduced against an invented function template + // F [...] F is a void function template with a single type template + // parameter T declared with the constrained-parameter. Form a new + // cv-qualifier-seq cv by taking the union of const and volatile specifiers + // around the constrained-parameter. F has a single parameter whose + // type-specifier is cv T followed by the abstract-declarator. [...] + // + // The cv part is done in the calling function - we get the concept with + // arguments and the abstract declarator with the correct CV qualification and + // have to synthesize T and the single parameter of F. + auto &II = Context.Idents.get("expr-type"); + auto *TParam = TemplateTypeParmDecl::Create(Context, CurContext, + SourceLocation(), + SourceLocation(), Depth, + /*Index=*/0, &II, + /*Typename=*/true, + /*ParameterPack=*/false, + /*HasTypeConstraint=*/true); + + if (ActOnTypeConstraint(TypeConstraint, TParam, + /*EllpsisLoc=*/SourceLocation())) + // Just produce a requirement with no type requirements. + return BuildExprRequirement(E, /*IsSimple=*/false, NoexceptLoc, {}); + + auto *TPL = TemplateParameterList::Create(Context, SourceLocation(), + SourceLocation(), + ArrayRef(TParam), + SourceLocation(), + /*RequiresClause=*/nullptr); + return BuildExprRequirement(E, /*IsSimple=*/false, NoexceptLoc, + ExprRequirement::ReturnTypeRequirement(TPL)); +} + +ExprRequirement * +Sema::BuildExprRequirement( + Expr *E, bool IsSimple, SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement) { + ExprRequirement::SatisfactionStatus Status = ExprRequirement::SS_Satisfied; + ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; + if (E->isInstantiationDependent() || ReturnTypeRequirement.isDependent()) + Status = ExprRequirement::SS_Dependent; + else if (NoexceptLoc.isValid() && canThrow(E) == CanThrowResult::CT_Can) + Status = ExprRequirement::SS_NoexceptNotMet; + else if (ReturnTypeRequirement.isSubstitutionFailure()) + Status = ExprRequirement::SS_TypeRequirementSubstitutionFailure; + else if (ReturnTypeRequirement.isTypeConstraint()) { + // C++2a [expr.prim.req]p1.3.3 + // The immediately-declared constraint ([temp]) of decltype((E)) shall + // be satisfied. + TemplateParameterList *TPL = + ReturnTypeRequirement.getTypeConstraintTemplateParameterList(); + QualType MatchedType = + BuildDecltypeType(E, E->getBeginLoc()).getCanonicalType(); + llvm::SmallVector Args; + Args.push_back(TemplateArgument(MatchedType)); + TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args); + MultiLevelTemplateArgumentList MLTAL(TAL); + for (unsigned I = 0; I < TPL->getDepth(); ++I) + MLTAL.addOuterRetainedLevel(); + Expr *IDC = + cast(TPL->getParam(0))->getTypeConstraint() + ->getImmediatelyDeclaredConstraint(); + ExprResult Constraint = SubstExpr(IDC, MLTAL); + assert(!Constraint.isInvalid() && + "Substitution cannot fail as it is simply putting a type template " + "argument into a concept specialization expression's parameter."); + + SubstitutedConstraintExpr = + cast(Constraint.get()); + if (!SubstitutedConstraintExpr->isSatisfied()) + Status = ExprRequirement::SS_ConstraintsNotSatisfied; + } + return new (Context) ExprRequirement(E, IsSimple, NoexceptLoc, + ReturnTypeRequirement, Status, + SubstitutedConstraintExpr); +} + +ExprRequirement * +Sema::BuildExprRequirement( + Requirement::SubstitutionDiagnostic *ExprSubstitutionDiagnostic, + bool IsSimple, SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement) { + return new (Context) ExprRequirement(ExprSubstitutionDiagnostic, IsSimple, + NoexceptLoc, ReturnTypeRequirement); +} + +TypeRequirement * +Sema::BuildTypeRequirement(TypeSourceInfo *Type) { + return new (Context) TypeRequirement(Type); +} + +TypeRequirement * +Sema::BuildTypeRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) { + return new (Context) TypeRequirement(SubstDiag); +} + +Requirement *Sema::ActOnNestedRequirement(Expr *Constraint) { + return BuildNestedRequirement(Constraint); +} + +NestedRequirement * +Sema::BuildNestedRequirement(Expr *Constraint) { + ConstraintSatisfaction Satisfaction; + if (!Constraint->isInstantiationDependent() && + CheckConstraintSatisfaction(Constraint, Satisfaction)) + return nullptr; + return new (Context) NestedRequirement(Context, Constraint, + Satisfaction); +} + +NestedRequirement * +Sema::BuildNestedRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) { + return new (Context) NestedRequirement(SubstDiag); +} + +RequiresExprBodyDecl * +Sema::ActOnEnterRequiresExpr(SourceLocation RequiresKWLoc, + ArrayRef LocalParameters, + Scope *BodyScope) { + assert(BodyScope); + + RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(Context, CurContext, + RequiresKWLoc); + + // Maintain an efficient lookup of params we have seen so far. + llvm::SmallSet ParamsSoFar; + + PushDeclContext(BodyScope, Body); + + for (ParmVarDecl *Param : LocalParameters) { + if (Param->hasDefaultArg()) + // C++2a [expr.prim.req] p4 + // [...] A local parameter of a requires-expression shall not have a + // default argument. [...] + Diag(Param->getDefaultArgRange().getBegin(), + diag::err_requires_expr_local_parameter_default_argument); + // Ignore default argument and move on + + Param->setDeclContext(Body); + // If this has an identifier, add it to the scope stack. + if (Param->getIdentifier()) { + CheckShadow(BodyScope, Param); + + PushOnScopeChains(Param, BodyScope); + + // Verify that the argument identifier has not already been mentioned. + if (!ParamsSoFar.insert(Param->getIdentifier()).second) + Diag(Param->getBeginLoc(), diag::err_param_redefinition) + << Param->getIdentifier(); + } + } + return Body; +} + +void Sema::ActOnExitRequiresExpr() { + assert(CurContext && "DeclContext imbalance!"); + CurContext = CurContext->getLexicalParent(); + assert(CurContext && "Popped translation unit!"); +} + +ExprResult +Sema::CreateRequiresExpr(SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation ClosingBraceLoc) { + return RequiresExpr::Create(Context, RequiresKWLoc, Body, LocalParameters, + Requirements, ClosingBraceLoc); +} Index: clang/lib/Sema/SemaLookup.cpp =================================================================== --- clang/lib/Sema/SemaLookup.cpp +++ clang/lib/Sema/SemaLookup.cpp @@ -1575,7 +1575,9 @@ unsigned N = CodeSynthesisContexts.size(); for (unsigned I = CodeSynthesisContextLookupModules.size(); I != N; ++I) { - Module *M = getDefiningModule(*this, CodeSynthesisContexts[I].Entity); + Module *M = CodeSynthesisContexts[I].Entity ? + getDefiningModule(*this, CodeSynthesisContexts[I].Entity) : + nullptr; if (M && !LookupModulesCache.insert(M).second) M = nullptr; CodeSynthesisContextLookupModules.push_back(M); Index: clang/lib/Sema/SemaTemplateInstantiate.cpp =================================================================== --- clang/lib/Sema/SemaTemplateInstantiate.cpp +++ clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -26,6 +26,7 @@ #include "clang/Sema/Template.h" #include "clang/Sema/TemplateDeduction.h" #include "clang/Sema/TemplateInstCallback.h" +#include "clang/Sema/SemaConcept.h" #include "llvm/Support/TimeProfiler.h" using namespace clang; @@ -199,8 +200,10 @@ case DeducedTemplateArgumentSubstitution: case PriorTemplateArgumentSubstitution: case ConstraintsCheck: + case NestedRequirementConstraintsCheck: return true; + case RequirementInstantiation: case DefaultTemplateArgumentChecking: case DeclaringSpecialMember: case DeclaringImplicitEqualityComparison: @@ -247,7 +250,7 @@ Inst.InstantiationRange = InstantiationRange; SemaRef.pushCodeSynthesisContext(Inst); - AlreadyInstantiating = + AlreadyInstantiating = !Inst.Entity ? false : !SemaRef.InstantiatingSpecializations .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind)) .second; @@ -364,6 +367,24 @@ PointOfInstantiation, InstantiationRange, Param, Template, TemplateArgs) {} +Sema::InstantiatingTemplate::InstantiatingTemplate( + Sema &SemaRef, SourceLocation PointOfInstantiation, Requirement *Req, + sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange) + : InstantiatingTemplate( + SemaRef, CodeSynthesisContext::RequirementInstantiation, + PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr, + /*Template=*/nullptr, /*TemplateArgs=*/None, &DeductionInfo) {} + + +Sema::InstantiatingTemplate::InstantiatingTemplate( + Sema &SemaRef, SourceLocation PointOfInstantiation, NestedRequirement *Req, + ConstraintsCheck, SourceRange InstantiationRange) + : InstantiatingTemplate( + SemaRef, CodeSynthesisContext::NestedRequirementConstraintsCheck, + PointOfInstantiation, InstantiationRange, /*Entity=*/nullptr, + /*Template=*/nullptr, /*TemplateArgs=*/None) {} + + Sema::InstantiatingTemplate::InstantiatingTemplate( Sema &SemaRef, SourceLocation PointOfInstantiation, ConstraintsCheck, NamedDecl *Template, @@ -446,8 +467,9 @@ if (!Invalid) { if (!AlreadyInstantiating) { auto &Active = SemaRef.CodeSynthesisContexts.back(); - SemaRef.InstantiatingSpecializations.erase( - std::make_pair(Active.Entity, Active.Kind)); + if (Active.Entity) + SemaRef.InstantiatingSpecializations.erase( + std::make_pair(Active.Entity, Active.Kind)); } atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef, @@ -684,6 +706,18 @@ << Active->InstantiationRange; break; + case CodeSynthesisContext::RequirementInstantiation: + Diags.Report(Active->PointOfInstantiation, + diag::note_template_requirement_instantiation_here) + << Active->InstantiationRange; + break; + + case CodeSynthesisContext::NestedRequirementConstraintsCheck: + Diags.Report(Active->PointOfInstantiation, + diag::note_nested_requirement_here) + << Active->InstantiationRange; + break; + case CodeSynthesisContext::DeclaringSpecialMember: Diags.Report(Active->PointOfInstantiation, diag::note_in_declaration_of_implicit_special_member) @@ -788,6 +822,7 @@ case CodeSynthesisContext::ConstraintsCheck: case CodeSynthesisContext::ParameterMappingSubstitution: case CodeSynthesisContext::ConstraintNormalization: + case CodeSynthesisContext::NestedRequirementConstraintsCheck: // This is a template instantiation, so there is no SFINAE. return None; @@ -802,9 +837,10 @@ case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: case CodeSynthesisContext::ConstraintSubstitution: - // We're either substituting explicitly-specified template arguments - // or deduced template arguments or a constraint expression, so SFINAE - // applies. + case CodeSynthesisContext::RequirementInstantiation: + // We're either substituting explicitly-specified template arguments, + // deduced template arguments, a constraint expression or a requirement + // in a requires expression, so SFINAE applies. assert(Active->DeductionInfo && "Missing deduction info pointer"); return Active->DeductionInfo; @@ -1056,6 +1092,39 @@ return TreeTransform::TransformLambdaExpr(E); } + ExprResult TransformRequiresExpr(RequiresExpr *E) { + LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true); + return TreeTransform::TransformRequiresExpr(E); + } + + bool TransformRequiresExprRequirements(ArrayRef Reqs, + SmallVectorImpl &Transformed) { + bool SatisfactionDetermined = false; + for (Requirement *Req : Reqs) { + Requirement *TransReq = nullptr; + if (!SatisfactionDetermined) { + if (auto *TypeReq = dyn_cast(Req)) + TransReq = TransformTypeRequirement(TypeReq); + else if (auto *ExprReq = dyn_cast(Req)) + TransReq = TransformExprRequirement(ExprReq); + else + TransReq = TransformNestedRequirement(cast(Req)); + if (!TransReq) + return true; + if (!TransReq->isDependent() && !TransReq->isSatisfied()) + // [expr.prim.req]p6 + // [...] The substitution and semantic constraint checking + // proceeds in lexical order and stops when a condition that + // determines the result of the requires-expression is + // encountered. [..] + SatisfactionDetermined = true; + } else + TransReq = Req; + Transformed.push_back(TransReq); + } + return false; + } + TemplateParameterList *TransformTemplateParameterList( TemplateParameterList *OrigTPL) { if (!OrigTPL || !OrigTPL->size()) return OrigTPL; @@ -1065,6 +1134,11 @@ /* DeclContext *Owner */ Owner, TemplateArgs); return DeclInstantiator.SubstTemplateParams(OrigTPL); } + + TypeRequirement *TransformTypeRequirement(TypeRequirement *Req); + ExprRequirement *TransformExprRequirement(ExprRequirement *Req); + NestedRequirement *TransformNestedRequirement(NestedRequirement *Req); + private: ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm, SourceLocation loc, @@ -1669,6 +1743,161 @@ return Result; } +template +static Requirement::SubstitutionDiagnostic * +createSubstDiag(Sema &S, TemplateDeductionInfo &Info, EntityPrinter Printer) { + SmallString<128> Message; + SourceLocation ErrorLoc; + if (Info.hasSFINAEDiagnostic()) { + PartialDiagnosticAt PDA(SourceLocation(), + PartialDiagnostic::NullDiagnostic{}); + Info.takeSFINAEDiagnostic(PDA); + PDA.second.EmitToString(S.getDiagnostics(), Message); + ErrorLoc = PDA.first; + } else { + ErrorLoc = Info.getLocation(); + } + char *MessageBuf = new (S.Context) char[Message.size()]; + std::copy(Message.begin(), Message.end(), MessageBuf); + SmallString<128> Entity; + llvm::raw_svector_ostream OS(Entity); + Printer(OS); + char *EntityBuf = new (S.Context) char[Entity.size()]; + std::copy(Entity.begin(), Entity.end(), EntityBuf); + return new (S.Context) Requirement::SubstitutionDiagnostic{ + StringRef(EntityBuf, Entity.size()), ErrorLoc, + StringRef(MessageBuf, Message.size())}; +} + +TypeRequirement * +TemplateInstantiator::TransformTypeRequirement(TypeRequirement *Req) { + if (!Req->isDependent() && !AlwaysRebuild()) + return Req; + if (Req->isSubstitutionFailure()) { + if (AlwaysRebuild()) + return RebuildTypeRequirement( + Req->getSubstitutionDiagnostic()); + return Req; + } + + Sema::SFINAETrap Trap(SemaRef); + TemplateDeductionInfo Info(Req->getType()->getTypeLoc().getBeginLoc()); + Sema::InstantiatingTemplate TypeInst(SemaRef, + Req->getType()->getTypeLoc().getBeginLoc(), Req, Info, + Req->getType()->getTypeLoc().getSourceRange()); + if (TypeInst.isInvalid()) + return nullptr; + TypeSourceInfo *TransType = TransformType(Req->getType()); + if (!TransType || Trap.hasErrorOccurred()) + return RebuildTypeRequirement(createSubstDiag(SemaRef, Info, + [&] (llvm::raw_ostream& OS) { + Req->getType()->getType().print(OS, SemaRef.getPrintingPolicy()); + })); + return RebuildTypeRequirement(TransType); +} + +ExprRequirement * +TemplateInstantiator::TransformExprRequirement(ExprRequirement *Req) { + if (!Req->isDependent() && !AlwaysRebuild()) + return Req; + + Sema::SFINAETrap Trap(SemaRef); + TemplateDeductionInfo Info(Req->getExpr()->getBeginLoc()); + + llvm::PointerUnion TransExpr; + if (Req->isExprSubstitutionFailure()) + TransExpr = Req->getExprSubstitutionDiagnostic(); + else { + Sema::InstantiatingTemplate ExprInst(SemaRef, Req->getExpr()->getBeginLoc(), + Req, Info, + Req->getExpr()->getSourceRange()); + if (ExprInst.isInvalid()) + return nullptr; + ExprResult TransExprRes = TransformExpr(Req->getExpr()); + if (TransExprRes.isInvalid() || Trap.hasErrorOccurred()) + TransExpr = createSubstDiag(SemaRef, Info, + [&] (llvm::raw_ostream& OS) { + Req->getExpr()->printPretty(OS, nullptr, + SemaRef.getPrintingPolicy()); + }); + else + TransExpr = TransExprRes.get(); + } + + llvm::Optional TransRetReq; + const auto &RetReq = Req->getReturnTypeRequirement(); + if (RetReq.isEmpty()) + TransRetReq.emplace(); + else if (RetReq.isSubstitutionFailure()) + TransRetReq.emplace(RetReq.getSubstitutionDiagnostic()); + else if (RetReq.isTypeConstraint()) { + TemplateParameterList *OrigTPL = + RetReq.getTypeConstraintTemplateParameterList(); + Sema::InstantiatingTemplate TPLInst(SemaRef, OrigTPL->getTemplateLoc(), + Req, Info, OrigTPL->getSourceRange()); + if (TPLInst.isInvalid()) + return nullptr; + TemplateParameterList *TPL = + TransformTemplateParameterList(OrigTPL); + if (!TPL) + TransRetReq.emplace(createSubstDiag(SemaRef, Info, + [&] (llvm::raw_ostream& OS) { + RetReq.getTypeConstraint()->getImmediatelyDeclaredConstraint() + ->printPretty(OS, nullptr, SemaRef.getPrintingPolicy()); + })); + else { + TPLInst.Clear(); + TransRetReq.emplace(TPL); + } + } + assert(TransRetReq.hasValue() && + "All code paths leading here must set TransRetReq"); + if (Expr *E = TransExpr.dyn_cast()) + return RebuildExprRequirement(E, Req->isSimple(), Req->getNoexceptLoc(), + std::move(*TransRetReq)); + return RebuildExprRequirement( + TransExpr.get(), Req->isSimple(), + Req->getNoexceptLoc(), std::move(*TransRetReq)); +} + +NestedRequirement * +TemplateInstantiator::TransformNestedRequirement(NestedRequirement *Req) { + if (!Req->isDependent() && !AlwaysRebuild()) + return Req; + if (Req->isSubstitutionFailure()) { + if (AlwaysRebuild()) + return RebuildNestedRequirement( + Req->getSubstitutionDiagnostic()); + return Req; + } + Sema::InstantiatingTemplate ReqInst(SemaRef, + Req->getConstraintExpr()->getBeginLoc(), Req, + Sema::InstantiatingTemplate::ConstraintsCheck{}, + Req->getConstraintExpr()->getSourceRange()); + + ExprResult TransConstraint; + TemplateDeductionInfo Info(Req->getConstraintExpr()->getBeginLoc()); + { + EnterExpressionEvaluationContext ContextRAII( + SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated); + Sema::SFINAETrap Trap(SemaRef); + Sema::InstantiatingTemplate ConstrInst(SemaRef, + Req->getConstraintExpr()->getBeginLoc(), Req, Info, + Req->getConstraintExpr()->getSourceRange()); + if (ConstrInst.isInvalid()) + return nullptr; + TransConstraint = TransformExpr(Req->getConstraintExpr()); + if (TransConstraint.isInvalid() || Trap.hasErrorOccurred()) + return RebuildNestedRequirement(createSubstDiag(SemaRef, Info, + [&] (llvm::raw_ostream& OS) { + Req->getConstraintExpr()->printPretty(OS, nullptr, + SemaRef.getPrintingPolicy()); + })); + } + return RebuildNestedRequirement(TransConstraint.get()); +} + + /// Perform substitution on the type T with a given set of template /// arguments. /// Index: clang/lib/Sema/SemaTemplateInstantiateDecl.cpp =================================================================== --- clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -3602,6 +3602,12 @@ llvm_unreachable("Concept definitions cannot reside inside a template"); } +Decl * +TemplateDeclInstantiator::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) { + return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(), + D->getBeginLoc()); +} + Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) { llvm_unreachable("Unexpected decl"); } Index: clang/lib/Sema/SemaType.cpp =================================================================== --- clang/lib/Sema/SemaType.cpp +++ clang/lib/Sema/SemaType.cpp @@ -2994,6 +2994,9 @@ case DeclaratorContext::PrototypeContext: Error = 0; break; + case DeclaratorContext::RequiresExprContext: + Error = 21; + break; case DeclaratorContext::LambdaExprParameterContext: // In C++14, generic lambdas allow 'auto' in their parameters. if (!SemaRef.getLangOpts().CPlusPlus14 || @@ -3221,6 +3224,7 @@ case DeclaratorContext::ObjCParameterContext: case DeclaratorContext::ObjCResultContext: case DeclaratorContext::KNRTypeListContext: + case DeclaratorContext::RequiresExprContext: // C++ [dcl.fct]p6: // Types shall not be defined in return or parameter types. DiagID = diag::err_type_defined_in_param_type; @@ -4279,6 +4283,7 @@ case DeclaratorContext::TemplateTypeArgContext: case DeclaratorContext::TypeNameContext: case DeclaratorContext::FunctionalCastContext: + case DeclaratorContext::RequiresExprContext: // Don't infer in these contexts. break; } @@ -5227,6 +5232,7 @@ switch (D.getContext()) { case DeclaratorContext::PrototypeContext: case DeclaratorContext::LambdaExprParameterContext: + case DeclaratorContext::RequiresExprContext: // C++0x [dcl.fct]p13: // [...] When it is part of a parameter-declaration-clause, the // parameter pack is a function parameter pack (14.5.3). The type T Index: clang/lib/Sema/TreeTransform.h =================================================================== --- clang/lib/Sema/TreeTransform.h +++ clang/lib/Sema/TreeTransform.h @@ -509,6 +509,12 @@ DeclarationNameInfo TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo); + bool TransformRequiresExprRequirements(ArrayRef Reqs, + llvm::SmallVectorImpl &Transformed); + TypeRequirement *TransformTypeRequirement(TypeRequirement *Req); + ExprRequirement *TransformExprRequirement(ExprRequirement *Req); + NestedRequirement *TransformNestedRequirement(NestedRequirement *Req); + /// Transform the given template name. /// /// \param SS The nested-name-specifier that qualifies the template @@ -3075,7 +3081,58 @@ return Result; } - /// \brief Build a new Objective-C boxed expression. + /// \brief Build a new requires expression. + /// + /// By default, performs semantic analysis to build the new expression. + /// Subclasses may override this routine to provide different behavior. + ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc, + RequiresExprBodyDecl *Body, + ArrayRef LocalParameters, + ArrayRef Requirements, + SourceLocation ClosingBraceLoc) { + ExprResult Result = getSema().CreateRequiresExpr(RequiresKWLoc, Body, + LocalParameters, + Requirements, + ClosingBraceLoc); + if (Result.isInvalid()) + return ExprError(); + return Result; + } + + TypeRequirement * + RebuildTypeRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) { + return SemaRef.BuildTypeRequirement(SubstDiag); + } + + TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) { + return SemaRef.BuildTypeRequirement(T); + } + + ExprRequirement * + RebuildExprRequirement(Requirement::SubstitutionDiagnostic *SubstDiag, + bool IsSimple, SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement Ret) { + return SemaRef.BuildExprRequirement(SubstDiag, IsSimple, NoexceptLoc, + std::move(Ret)); + } + + ExprRequirement * + RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc, + ExprRequirement::ReturnTypeRequirement Ret) { + return SemaRef.BuildExprRequirement(E, IsSimple, NoexceptLoc, + std::move(Ret)); + } + + NestedRequirement * + RebuildNestedRequirement(Requirement::SubstitutionDiagnostic *SubstDiag) { + return SemaRef.BuildNestedRequirement(SubstDiag); + } + + NestedRequirement *RebuildNestedRequirement(Expr *Constraint) { + return SemaRef.BuildNestedRequirement(Constraint); + } + + /// \brief Build a new Objective-C boxed expression. /// /// By default, performs semantic analysis to build the new expression. /// Subclasses may override this routine to provide different behavior. @@ -11175,6 +11232,141 @@ &TransArgs); } +template +ExprResult +TreeTransform::TransformRequiresExpr(RequiresExpr *E) { + SmallVector TransParams; + SmallVector TransParamTypes; + Sema::ExtParameterInfoBuilder ExtParamInfos; + + // C++2a [expr.prim.req]p2 + // Expressions appearing within a requirement-body are unevaluated operands. + EnterExpressionEvaluationContext Ctx( + SemaRef, Sema::ExpressionEvaluationContext::Unevaluated); + + RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create( + getSema().Context, E->getBody()->getDeclContext(), + E->getBody()->getBeginLoc()); + + Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false); + + if (getDerived().TransformFunctionTypeParams(E->getRequiresKWLoc(), + E->getLocalParameters(), + /*ParamTypes=*/nullptr, + /*ParamInfos=*/nullptr, + TransParamTypes, &TransParams, + ExtParamInfos)) + return ExprError(); + + for (ParmVarDecl *Param : TransParams) + Param->setDeclContext(Body); + + SmallVector TransReqs; + if (getDerived().TransformRequiresExprRequirements(E->getRequirements(), + TransReqs)) + return ExprError(); + + for (Requirement *Req : TransReqs) + if (auto *ER = dyn_cast(Req)) + if (ER->getReturnTypeRequirement().isTypeConstraint()) + ER->getReturnTypeRequirement() + .getTypeConstraintTemplateParameterList()->getParam(0) + ->setDeclContext(Body); + + return getDerived().RebuildRequiresExpr(E->getRequiresKWLoc(), Body, + TransParams, TransReqs, + E->getRBraceLoc()); +} + +template +bool TreeTransform::TransformRequiresExprRequirements( + ArrayRef Reqs, + SmallVectorImpl &Transformed) { + for (Requirement *Req : Reqs) { + Requirement *TransReq = nullptr; + if (auto *TypeReq = dyn_cast(Req)) + TransReq = getDerived().TransformTypeRequirement(TypeReq); + else if (auto *ExprReq = dyn_cast(Req)) + TransReq = getDerived().TransformExprRequirement(ExprReq); + else + TransReq = getDerived().TransformNestedRequirement( + cast(Req)); + if (!TransReq) + return true; + Transformed.push_back(TransReq); + } + return false; +} + +template +TypeRequirement * +TreeTransform::TransformTypeRequirement(TypeRequirement *Req) { + if (Req->isSubstitutionFailure()) { + if (getDerived().AlwaysRebuild()) + return getDerived().RebuildTypeRequirement( + Req->getSubstitutionDiagnostic()); + return Req; + } + TypeSourceInfo *TransType = getDerived().TransformType(Req->getType()); + if (!TransType) + return nullptr; + return getDerived().RebuildTypeRequirement(TransType); +} + +template +ExprRequirement * +TreeTransform::TransformExprRequirement(ExprRequirement *Req) { + llvm::PointerUnion TransExpr; + if (Req->isExprSubstitutionFailure()) + TransExpr = Req->getExprSubstitutionDiagnostic(); + else { + ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr()); + if (TransExprRes.isInvalid()) + return nullptr; + TransExpr = TransExprRes.get(); + } + + llvm::Optional TransRetReq; + const auto &RetReq = Req->getReturnTypeRequirement(); + if (RetReq.isEmpty()) + TransRetReq.emplace(); + else if (RetReq.isSubstitutionFailure()) + TransRetReq.emplace(RetReq.getSubstitutionDiagnostic()); + else if (RetReq.isTypeConstraint()) { + TemplateParameterList *OrigTPL = + RetReq.getTypeConstraintTemplateParameterList(); + TemplateParameterList *TPL = + getDerived().TransformTemplateParameterList(OrigTPL); + if (!TPL) + return nullptr; + TransRetReq.emplace(TPL); + } + assert(TransRetReq.hasValue() && + "All code paths leading here must set TransRetReq"); + if (Expr *E = TransExpr.dyn_cast()) + return getDerived().RebuildExprRequirement(E, Req->isSimple(), + Req->getNoexceptLoc(), + std::move(*TransRetReq)); + return getDerived().RebuildExprRequirement( + TransExpr.get(), Req->isSimple(), + Req->getNoexceptLoc(), std::move(*TransRetReq)); +} + +template +NestedRequirement * +TreeTransform::TransformNestedRequirement(NestedRequirement *Req) { + if (Req->isSubstitutionFailure()) { + if (getDerived().AlwaysRebuild()) + return getDerived().RebuildNestedRequirement( + Req->getSubstitutionDiagnostic()); + return Req; + } + ExprResult TransConstraint = + getDerived().TransformExpr(Req->getConstraintExpr()); + if (TransConstraint.isInvalid()) + return nullptr; + return getDerived().RebuildNestedRequirement(TransConstraint.get()); +} template ExprResult Index: clang/lib/Serialization/ASTCommon.cpp =================================================================== --- clang/lib/Serialization/ASTCommon.cpp +++ clang/lib/Serialization/ASTCommon.cpp @@ -402,6 +402,7 @@ case Decl::Binding: case Decl::Concept: case Decl::LifetimeExtendedTemporary: + case Decl::RequiresExprBody: return false; // These indirectly derive from Redeclarable but are not actually Index: clang/lib/Serialization/ASTReaderDecl.cpp =================================================================== --- clang/lib/Serialization/ASTReaderDecl.cpp +++ clang/lib/Serialization/ASTReaderDecl.cpp @@ -375,6 +375,7 @@ void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); DeclID VisitTemplateDecl(TemplateDecl *D); void VisitConceptDecl(ConceptDecl *D); + void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D); RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); void VisitClassTemplateDecl(ClassTemplateDecl *D); void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D); @@ -2026,6 +2027,9 @@ mergeMergeable(D); } +void ASTDeclReader::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) { +} + ASTDeclReader::RedeclarableResult ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { RedeclarableResult Redecl = VisitRedeclarable(D); @@ -3828,6 +3832,9 @@ case DECL_CONCEPT: D = ConceptDecl::CreateDeserialized(Context, ID); break; + case DECL_REQUIRES_EXPR_BODY: + D = RequiresExprBodyDecl::CreateDeserialized(Context, ID); + break; case DECL_STATIC_ASSERT: D = StaticAssertDecl::CreateDeserialized(Context, ID); break; Index: clang/lib/Serialization/ASTReaderStmt.cpp =================================================================== --- clang/lib/Serialization/ASTReaderStmt.cpp +++ clang/lib/Serialization/ASTReaderStmt.cpp @@ -724,28 +724,15 @@ E->setRParenLoc(readSourceLocation()); } -void ASTStmtReader::VisitConceptSpecializationExpr( - ConceptSpecializationExpr *E) { - VisitExpr(E); - unsigned NumTemplateArgs = Record.readInt(); - E->NestedNameSpec = Record.readNestedNameSpecifierLoc(); - E->TemplateKWLoc = Record.readSourceLocation(); - E->ConceptName = Record.readDeclarationNameInfo(); - E->NamedConcept = readDeclAs(); - const ASTTemplateArgumentListInfo *ArgsAsWritten = - Record.readASTTemplateArgumentListInfo(); - llvm::SmallVector Args; - for (unsigned I = 0; I < NumTemplateArgs; ++I) - Args.push_back(Record.readTemplateArgument()); - E->setTemplateArguments(ArgsAsWritten, Args); +static ConstraintSatisfaction +readConstraintSatisfaction(ASTRecordReader &Record) { ConstraintSatisfaction Satisfaction; Satisfaction.IsSatisfied = Record.readInt(); if (!Satisfaction.IsSatisfied) { unsigned NumDetailRecords = Record.readInt(); for (unsigned i = 0; i != NumDetailRecords; ++i) { Expr *ConstraintExpr = Record.readExpr(); - bool IsDiagnostic = Record.readInt(); - if (IsDiagnostic) { + if (bool IsDiagnostic = Record.readInt()) { SourceLocation DiagLocation = Record.readSourceLocation(); std::string DiagMessage = Record.readString(); Satisfaction.Details.emplace_back( @@ -756,8 +743,131 @@ Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr()); } } - E->Satisfaction = ASTConstraintSatisfaction::Create(Record.getContext(), - Satisfaction); + return Satisfaction; +} + +void ASTStmtReader::VisitConceptSpecializationExpr( + ConceptSpecializationExpr *E) { + VisitExpr(E); + unsigned NumTemplateArgs = Record.readInt(); + E->NestedNameSpec = Record.readNestedNameSpecifierLoc(); + E->TemplateKWLoc = Record.readSourceLocation(); + E->ConceptName = Record.readDeclarationNameInfo(); + E->NamedConcept = readDeclAs(); + const ASTTemplateArgumentListInfo *ArgsAsWritten = + Record.readASTTemplateArgumentListInfo(); + llvm::SmallVector Args; + for (unsigned I = 0; I < NumTemplateArgs; ++I) + Args.push_back(Record.readTemplateArgument()); + E->setTemplateArguments(ArgsAsWritten, Args); + E->Satisfaction = E->isValueDependent() ? nullptr : + ASTConstraintSatisfaction::Create(Record.getContext(), + readConstraintSatisfaction(Record)); +} + +static Requirement::SubstitutionDiagnostic * +readSubstitutionDiagnostic(ASTRecordReader &Record) { + std::string SubstitutedEntity = Record.readString(); + SourceLocation DiagLoc = Record.readSourceLocation(); + std::string DiagMessage = Record.readString(); + return new (Record.getContext()) Requirement::SubstitutionDiagnostic{ + SubstitutedEntity, DiagLoc, DiagMessage}; +} + +void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) { + VisitExpr(E); + unsigned NumLocalParameters = Record.readInt(); + unsigned NumRequirements = Record.readInt(); + E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation(); + E->RequiresExprBits.IsSatisfied = Record.readInt(); + E->Body = Record.readDeclAs(); + llvm::SmallVector LocalParameters; + for (unsigned i = 0; i < NumLocalParameters; ++i) + LocalParameters.push_back(cast(Record.readDecl())); + std::copy(LocalParameters.begin(), LocalParameters.end(), + E->getTrailingObjects()); + llvm::SmallVector Requirements; + for (unsigned i = 0; i < NumRequirements; ++i) { + auto RK = static_cast(Record.readInt()); + Requirement *R = nullptr; + switch (RK) { + case Requirement::RK_Type: { + auto Status = + static_cast(Record.readInt()); + if (Status == TypeRequirement::SS_SubstitutionFailure) + R = new (Record.getContext()) TypeRequirement( + readSubstitutionDiagnostic(Record)); + else + R = new (Record.getContext()) TypeRequirement( + Record.readTypeSourceInfo()); + } break; + case Requirement::RK_Simple: + case Requirement::RK_Compound: { + auto Status = + static_cast(Record.readInt()); + llvm::PointerUnion E; + if (Status == ExprRequirement::SS_ExprSubstitutionFailure) { + E = readSubstitutionDiagnostic(Record); + } else + E = Record.readExpr(); + + llvm::Optional Req; + ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; + SourceLocation NoexceptLoc; + if (RK == Requirement::RK_Simple) { + Req.emplace(); + } else { + NoexceptLoc = Record.readSourceLocation(); + switch (auto returnTypeRequirementKind = Record.readInt()) { + case 0: + // No return type requirement. + Req.emplace(); + break; + case 1: { + // type-constraint + TemplateParameterList *TPL = Record.readTemplateParameterList(); + if (Status >= ExprRequirement::SS_ConstraintsNotSatisfied) + SubstitutedConstraintExpr = + cast(Record.readExpr()); + Req.emplace(TPL); + } break; + case 2: + // Substitution failure + Req.emplace(readSubstitutionDiagnostic(Record)); + break; + } + } + if (Expr *Ex = E.dyn_cast()) + R = new (Record.getContext()) ExprRequirement( + Ex, RK == Requirement::RK_Simple, NoexceptLoc, + std::move(*Req), Status, SubstitutedConstraintExpr); + else + R = new (Record.getContext()) ExprRequirement( + E.get(), + RK == Requirement::RK_Simple, NoexceptLoc, std::move(*Req)); + } break; + case Requirement::RK_Nested: { + if (bool IsSubstitutionDiagnostic = Record.readInt()) { + R = new (Record.getContext()) NestedRequirement( + readSubstitutionDiagnostic(Record)); + break; + } + Expr *E = Record.readExpr(); + if (E->isInstantiationDependent()) + R = new (Record.getContext()) NestedRequirement(E); + else + R = new (Record.getContext()) NestedRequirement(Record.getContext(), + E, readConstraintSatisfaction(Record)); + } break; + } + if (!R) + continue; + Requirements.push_back(R); + } + std::copy(Requirements.begin(), Requirements.end(), + E->getTrailingObjects()); + E->RBraceLoc = Record.readSourceLocation(); } void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { @@ -3567,11 +3677,18 @@ S = new (Context) DependentCoawaitExpr(Empty); break; - case EXPR_CONCEPT_SPECIALIZATION: + case EXPR_CONCEPT_SPECIALIZATION: { unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields]; S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs); break; - + } + + case EXPR_REQUIRES: + unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields]; + unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1]; + S = RequiresExpr::Create(Context, Empty, numLocalParameters, + numRequirement); + break; } // We hit a STMT_STOP, so we're done with this expression. Index: clang/lib/Serialization/ASTWriter.cpp =================================================================== --- clang/lib/Serialization/ASTWriter.cpp +++ clang/lib/Serialization/ASTWriter.cpp @@ -885,6 +885,7 @@ RECORD(DECL_NON_TYPE_TEMPLATE_PARM); RECORD(DECL_TEMPLATE_TEMPLATE_PARM); RECORD(DECL_CONCEPT); + RECORD(DECL_REQUIRES_EXPR_BODY); RECORD(DECL_TYPE_ALIAS_TEMPLATE); RECORD(DECL_STATIC_ASSERT); RECORD(DECL_CXX_BASE_SPECIFIERS); Index: clang/lib/Serialization/ASTWriterDecl.cpp =================================================================== --- clang/lib/Serialization/ASTWriterDecl.cpp +++ clang/lib/Serialization/ASTWriterDecl.cpp @@ -104,6 +104,7 @@ void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); void VisitTemplateDecl(TemplateDecl *D); void VisitConceptDecl(ConceptDecl *D); + void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D); void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D); void VisitClassTemplateDecl(ClassTemplateDecl *D); void VisitVarTemplateDecl(VarTemplateDecl *D); @@ -1482,6 +1483,10 @@ Code = serialization::DECL_CONCEPT; } +void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) { + Code = serialization::DECL_REQUIRES_EXPR_BODY; +} + void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) { VisitRedeclarable(D); Index: clang/lib/Serialization/ASTWriterStmt.cpp =================================================================== --- clang/lib/Serialization/ASTWriterStmt.cpp +++ clang/lib/Serialization/ASTWriterStmt.cpp @@ -12,6 +12,7 @@ //===----------------------------------------------------------------------===// #include "clang/Serialization/ASTRecordWriter.h" +#include "clang/Sema/DeclSpec.h" #include "clang/AST/ASTContext.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" @@ -388,19 +389,9 @@ Code = serialization::EXPR_DEPENDENT_COAWAIT; } -void ASTStmtWriter::VisitConceptSpecializationExpr( - ConceptSpecializationExpr *E) { - VisitExpr(E); - ArrayRef TemplateArgs = E->getTemplateArguments(); - Record.push_back(TemplateArgs.size()); - Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc()); - Record.AddSourceLocation(E->getTemplateKWLoc()); - Record.AddDeclarationNameInfo(E->getConceptNameInfo()); - Record.AddDeclRef(E->getNamedConcept()); - Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten()); - for (const TemplateArgument &Arg : TemplateArgs) - Record.AddTemplateArgument(Arg); - const ASTConstraintSatisfaction &Satisfaction = E->getSatisfaction(); +static void +addConstraintSatisfaction(ASTRecordWriter &Record, + const ASTConstraintSatisfaction &Satisfaction) { Record.push_back(Satisfaction.IsSatisfied); if (!Satisfaction.IsSatisfied) { Record.push_back(Satisfaction.NumRecords); @@ -418,10 +409,96 @@ } } } +} + +static void +addSubstitutionDiagnostic(ASTRecordWriter &Record, + const Requirement::SubstitutionDiagnostic *D) { + Record.AddString(D->SubstitutedEntity); + Record.AddSourceLocation(D->DiagLoc); + Record.AddString(D->DiagMessage); +} + +void ASTStmtWriter::VisitConceptSpecializationExpr( + ConceptSpecializationExpr *E) { + VisitExpr(E); + ArrayRef TemplateArgs = E->getTemplateArguments(); + Record.push_back(TemplateArgs.size()); + Record.AddNestedNameSpecifierLoc(E->getNestedNameSpecifierLoc()); + Record.AddSourceLocation(E->getTemplateKWLoc()); + Record.AddDeclarationNameInfo(E->getConceptNameInfo()); + Record.AddDeclRef(E->getNamedConcept()); + Record.AddASTTemplateArgumentListInfo(E->getTemplateArgsAsWritten()); + for (const TemplateArgument &Arg : TemplateArgs) + Record.AddTemplateArgument(Arg); + if (!E->isValueDependent()) + addConstraintSatisfaction(Record, E->getSatisfaction()); Code = serialization::EXPR_CONCEPT_SPECIALIZATION; } +void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) { + VisitExpr(E); + Record.push_back(E->getLocalParameters().size()); + Record.push_back(E->getRequirements().size()); + Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc); + Record.push_back(E->RequiresExprBits.IsSatisfied); + Record.AddDeclRef(E->getBody()); + for (ParmVarDecl *P : E->getLocalParameters()) + Record.AddDeclRef(P); + for (Requirement *R : E->getRequirements()) { + if (auto *TypeReq = dyn_cast(R)) { + Record.push_back(Requirement::RK_Type); + Record.push_back(TypeReq->Status); + if (TypeReq->Status == TypeRequirement::SS_SubstitutionFailure) + addSubstitutionDiagnostic(Record, TypeReq->getSubstitutionDiagnostic()); + else + Record.AddTypeSourceInfo(TypeReq->getType()); + } else if (auto *ExprReq = dyn_cast(R)) { + Record.push_back(ExprReq->getKind()); + Record.push_back(ExprReq->Status); + if (ExprReq->isExprSubstitutionFailure()) { + addSubstitutionDiagnostic(Record, + ExprReq->Value.get()); + } else + Record.AddStmt(ExprReq->Value.get()); + if (ExprReq->getKind() == Requirement::RK_Compound) { + Record.AddSourceLocation(ExprReq->NoexceptLoc); + const auto &RetReq = ExprReq->getReturnTypeRequirement(); + if (RetReq.isSubstitutionFailure()) { + Record.push_back(2); + addSubstitutionDiagnostic(Record, RetReq.getSubstitutionDiagnostic()); + } else if (RetReq.isTypeConstraint()) { + Record.push_back(1); + Record.AddTemplateParameterList( + RetReq.getTypeConstraintTemplateParameterList()); + if (ExprReq->Status >= ExprRequirement::SS_ConstraintsNotSatisfied) + Record.AddStmt( + ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr()); + } else { + assert(RetReq.isEmpty()); + Record.push_back(0); + } + } + } else { + auto *NestedReq = cast(R); + Record.push_back(Requirement::RK_Nested); + Record.push_back(NestedReq->isSubstitutionFailure()); + if (NestedReq->isSubstitutionFailure()){ + addSubstitutionDiagnostic(Record, + NestedReq->getSubstitutionDiagnostic()); + } else { + Record.AddStmt(NestedReq->Value.get()); + if (!NestedReq->isDependent()) + addConstraintSatisfaction(Record, *NestedReq->Satisfaction); + } + } + } + Record.AddSourceLocation(E->getEndLoc()); + + Code = serialization::EXPR_REQUIRES; +} + void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) { VisitStmt(S); Index: clang/lib/StaticAnalyzer/Core/ExprEngine.cpp =================================================================== --- clang/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ clang/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -1386,6 +1386,7 @@ case Stmt::AsTypeExprClass: case Stmt::ConceptSpecializationExprClass: case Stmt::CXXRewrittenBinaryOperatorClass: + case Stmt::RequiresExprClass: // Fall through. // Cases we intentionally don't evaluate, since they don't need Index: clang/test/CXX/expr/expr.prim/expr.prim.req/compound-requirement.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/compound-requirement.cpp @@ -0,0 +1,175 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +static_assert(requires { { 0 }; }); +static_assert(requires { { "aaaa" }; }); +static_assert(requires { { (0).da }; }); // expected-error{{member reference base type 'int' is not a structure or union}} + +void foo() {} +static_assert(requires { { foo() }; }); + +// Substitution failure in expression + +struct A {}; +struct B { + B operator+(const B &other) const { return other; } +}; +struct C { + C operator+(C &other) const { return other; } +}; + +template requires requires (T a, const T& b) { { a + b }; } // expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('A' and 'const A')}} expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('C' and 'const C')}} +struct r1 {}; + +using r1i1 = r1; +using r1i2 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = A]}} +using r1i3 = r1; +using r1i4 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}} + +struct D { void foo() {} }; + +template requires requires (T a) { { a.foo() }; } // expected-note{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}} expected-note{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}} expected-note{{because 'a.foo()' would be invalid: 'this' argument to member function 'foo' has type 'const D', but function is not marked const}} +struct r2 {}; + +using r2i1 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}} +using r2i2 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}} +using r2i3 = r2; +using r2i4 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}} + +template requires requires { { sizeof(T) }; } // expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}} +struct r3 {}; + +using r3i1 = r3; +using r3i2 = r3; +using r3i3 = r3; +using r3i4 = r3; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}} +using r3i4 = r3; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}} + +// Non-dependent expressions + +template requires requires (T t) { { 0 }; { "a" }; { (void)'a' }; } +struct r4 {}; + +using r4i1 = r4; +using r4i2 = r4; +using r4i3 = r4; + +// Noexcept requirement +void maythrow() { } +static_assert(!requires { { maythrow() } noexcept; }); +static_assert(requires { { 1 } noexcept; }); + +struct E { void operator++(int) noexcept; }; +struct F { void operator++(int); }; + +template requires requires (T t) { { t++ } noexcept; } // expected-note{{because 't ++' may throw an exception}} +struct r5 {}; + +using r5i1 = r5; +using r5i2 = r5; +using r5i2 = r5; // expected-error{{constraints not satisfied for class template 'r5' [with T = F]}} + +template requires requires (T t) { { t.foo() } noexcept; } // expected-note{{because 't.foo()' would be invalid: no member named 'foo' in 'E'}} +struct r6 {}; + +using r6i = r6; // expected-error{{constraints not satisfied for class template 'r6' [with T = E]}} + +template +constexpr bool is_same_v = false; + +template +constexpr bool is_same_v = true; + +template +concept Same = is_same_v; + +template +concept Large = sizeof(T) >= 4; // expected-note{{because 'sizeof(short) >= 4' (2 >= 4) evaluated to false}} + +template requires requires (T t) { { t } -> Large; } // expected-note{{because 'decltype(t)' (aka 'short') does not satisfy 'Large':}} +struct r7 {}; + +using r7i1 = r7; +using r7i2 = r7; // expected-error{{constraints not satisfied for class template 'r7' [with T = short]}} + +template requires requires (T t) { { t } -> Same; } +struct r8 {}; + +using r8i1 = r8; +using r8i2 = r8; + +// Substitution failure in type constraint + +template requires requires (T t) { { t } -> Same; } // expected-note{{because 'Same' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} +struct r9 {}; + +struct M { using type = M; }; + +using r9i1 = r9; +using r9i2 = r9; // expected-error{{constraints not satisfied for class template 'r9' [with T = int]}} + +// Substitution failure in both expression and return type requirement + +template requires requires (T t) { { t.foo() } -> Same; } // expected-note{{because 't.foo()' would be invalid: member reference base type 'int' is not a structure or union}} +struct r10 {}; + +using r10i = r10; // expected-error{{constraints not satisfied for class template 'r10' [with T = int]}} + +// Non-type concept in type constraint + +template +concept IsEven = (T % 2) == 0; + +template requires requires (T t) { { t } -> IsEven; } // expected-error{{concept named in type constraint must be a type concept}} +struct r11 {}; + +// C++ [expr.prim.req.compound] Example +namespace std_example { + template concept C1 = + requires(T x) { + {x++}; + }; + + template constexpr bool is_same_v = false; + template constexpr bool is_same_v = true; + + template concept same_as = is_same_v; + // expected-note@-1 {{because 'is_same_v' evaluated to false}} + + static_assert(C1); + static_assert(C1); + template struct C1_check {}; + using c1c1 = C1_check; + using c1c2 = C1_check; + + template concept C2 = + requires(T x) { + {*x} -> same_as; + // expected-note@-1{{because type constraint 'same_as' was not satisfied:}} + // expected-note@-2{{because '*x' would be invalid: indirection requires pointer operand ('int' invalid)}} + }; + + struct T1 { + using inner = int; + inner operator *() { return 0; } + }; + struct T2 { + using inner = int *; + int operator *() { return 0; } + }; + static_assert(C2); + template struct C2_check {}; // expected-note{{because 'int' does not satisfy 'C2'}} expected-note{{because 'std_example::T2' does not satisfy 'C2'}} + using c2c1 = C2_check; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = int]}} + using c2c2 = C2_check; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::T2]}} + + template + void g(T t) noexcept(sizeof(T) == 1) {} + + template concept C5 = + requires(T x) { + {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}} + }; + + static_assert(C5); + template struct C5_check {}; // expected-note{{because 'short' does not satisfy 'C5'}} + using c5 = C5_check; // expected-error{{constraints not satisfied for class template 'C5_check' [with T = short]}} +} \ No newline at end of file Index: clang/test/CXX/expr/expr.prim/expr.prim.req/equivalence.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/equivalence.cpp @@ -0,0 +1,125 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +template constexpr bool is_same_v = false; +template constexpr bool is_same_v = true; + +template struct identity { using type = T; }; +template using identity_t = T; + +// Type requirements +template requires requires { typename identity_t; } +struct r1; +template requires requires { typename identity_t; } // expected-note{{previous template declaration is here}} +struct r1; +template requires requires { typename identity_t; } // expected-error{{requires clause differs in template redeclaration}} +struct r1; +template requires requires { typename ::identity_t; } +struct r1; + +template requires requires { typename identity::type; } +struct r2; +template requires requires { typename identity::type; } +struct r2; +template requires requires { typename ::identity::type; } // expected-note 2{{previous template declaration is here}} +struct r2; +template requires requires { typename identity::typr; } // expected-error{{requires clause differs in template redeclaration}} +struct r2; +namespace ns { + template struct identity { using type = T; }; +} +template requires requires { typename ns::identity::type; } // expected-error{{requires clause differs in template redeclaration}} +struct r2; + +template requires requires { typename T::template identity::type; } +struct r3; +template requires requires { typename U::template identity::type; } // expected-note{{previous template declaration is here}} +struct r3; +template requires requires { typename T::template identitr::type; } // expected-error{{requires clause differs in template redeclaration}} +struct r3; + +template requires requires { typename T::template temp<>; } +struct r4; +template requires requires { typename U::template temp<>; } +struct r4; + +// Expr requirements +template requires requires { 0; } // expected-note{{previous template declaration is here}} +struct r5; +template requires requires { 1; } // expected-error{{requires clause differs in template redeclaration}} +struct r5; + +template +concept C1 = true; + +template requires requires { sizeof(T); } +struct r6; +template requires requires { sizeof(U); } // expected-note{{previous template declaration is here}} +struct r6; +template requires requires { sizeof(U) - 1; } // expected-error{{requires clause differs in template redeclaration}} +struct r6; +template requires requires { { sizeof(T) }; } // expected-note 2{{previous template declaration is here}} +struct r6; +template requires requires { { sizeof(T) } noexcept; } // expected-error{{requires clause differs in template redeclaration}} +struct r6; +template requires requires { { sizeof(T) } -> C1; } // expected-error{{requires clause differs in template redeclaration}} +struct r6; + +template requires requires { { sizeof(T) } -> C1; } +struct r7; +template requires requires { { sizeof(U) } -> C1; } +struct r7; +template requires requires { { sizeof(T) } -> C1<>; } // expected-note {{previous template declaration is here}} +struct r7; +template requires requires { { sizeof(U) }; } // expected-error{{requires clause differs in template redeclaration}} +struct r7; + +template +concept C2 = true; + +template requires requires { { sizeof(T) } -> C2; } +struct r8; +template requires requires { { sizeof(U) } -> C2; } // expected-note{{previous template declaration is here}} +struct r8; +template requires requires { { sizeof(T) } -> C2; } // expected-error{{requires clause differs in template redeclaration}} +struct r8; + +// Nested requirements +template requires requires { requires sizeof(T) == 0; } +struct r9; +template requires requires { requires sizeof(U) == 0; } // expected-note{{previous template declaration is here}} +struct r9; +template requires requires { requires sizeof(T) == 1; } // expected-error{{requires clause differs in template redeclaration}} +struct r9; + +// Parameter list +template requires requires { requires true; } +struct r10; +template requires requires() { requires true; } // expected-note{{previous template declaration is here}} +struct r10; +template requires requires(T i) { requires true; } // expected-error{{requires clause differs in template redeclaration}} +struct r10; + +template requires requires(T i, T *j) { requires true; } // expected-note 2{{previous template declaration is here}} +struct r11; +template requires requires(T i) { requires true; } // expected-error{{requires clause differs in template redeclaration}} +struct r11; +template requires requires(T i, T *j, T &k) { requires true; } // expected-error{{requires clause differs in template redeclaration}} +struct r11; + +// Parameter names +template requires requires(int i) { requires sizeof(i) == 1; } +struct r12; +template requires requires(int j) { requires sizeof(j) == 1; } // expected-note 2{{previous template declaration is here}} +struct r12; +template requires requires(int k) { requires sizeof(k) == 2; } // expected-error{{requires clause differs in template redeclaration}} +struct r12; +template requires requires(const int k) { requires sizeof(k) == 1; } // expected-error{{requires clause differs in template redeclaration}} +struct r12; + +// Order of requirements +template requires requires { requires true; 0; } +struct r13; +template requires requires { requires true; 0; } // expected-note{{previous template declaration is here}} +struct r13; +template requires requires { 0; requires true; } // expected-error{{requires clause differs in template redeclaration}} +struct r13; Index: clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +static_assert(requires { requires true; }); + +template requires requires { requires false; } // expected-note{{because 'false' evaluated to false}} +struct r1 {}; + +using r1i = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}} + +template requires requires { requires sizeof(T) == 0; } // expected-note{{because 'sizeof(int) == 0' (4 == 0) evaluated to false}} +struct r2 {}; + +using r2i = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}} + +template requires requires (T t) { requires sizeof(t) == 0; } // expected-note{{because 'sizeof (t) == 0' (4 == 0) evaluated to false}} +struct r3 {}; + +using r3i = r3; // expected-error{{constraints not satisfied for class template 'r3' [with T = int]}} + +template +struct X { + template requires requires (U u) { requires sizeof(u) == sizeof(T); } // expected-note{{because 'sizeof (u) == sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} + struct r4 {}; +}; + +using r4i = X::r4; // expected-error{{constraints not satisfied for class template 'r4' [with U = int]}} + +// C++ [expr.prim.req.nested] Examples +namespace std_example { + template concept C1 = sizeof(U) == 1; // expected-note{{because 'sizeof(int) == 1' (4 == 1) evaluated to false}} + template concept D = + requires (T t) { + requires C1; // expected-note{{because 'decltype(+t)' (aka 'int') does not satisfy 'C1'}} + }; + + struct T1 { char operator+() { return 'a'; } }; + static_assert(D); + template struct D_check {}; // expected-note{{because 'short' does not satisfy 'D'}} + using dc1 = D_check; // expected-error{{constraints not satisfied for class template 'D_check' [with T = short]}} + + template + concept C2 = requires (T a) { // expected-note{{'a' declared here}} + requires sizeof(a) == 4; // OK + requires a == 0; // expected-error{{constraint variable 'a' cannot be used in an evaluated context}} + }; +} \ No newline at end of file Index: clang/test/CXX/expr/expr.prim/expr.prim.req/p3.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/p3.cpp @@ -0,0 +1,37 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +// Examples from standard + +template +concept convertible_to = requires(T t) { U(t); }; + +template +concept R = requires (T i) { + typename T::type; + {*i} -> convertible_to; +}; + +template requires R struct S {}; + +struct T { + using type = int; + type i; + const type &operator*() { return i; } +}; + +using si = S; + +template +requires requires (T x) { x + x; } // expected-note{{because 'x + x' would be invalid: invalid operands to binary expression ('T' and 'T')}} +T add(T a, T b) { return a + b; } // expected-note{{candidate template ignored: constraints not satisfied [with T = T]}} + +int x = add(1, 2); +int y = add(T{}, T{}); // expected-error{{no matching function for call to 'add'}} + +template +concept C = requires (T x) { x + x; }; // expected-note{{because 'x + x' would be invalid: invalid operands to binary expression ('T' and 'T')}} +template requires C // expected-note{{because 'T' does not satisfy 'C'}} +T add2(T a, T b) { return a + b; } // expected-note{{candidate template ignored: constraints not satisfied [with T = T]}} + +int z = add2(1, 2); +int w = add2(T{}, T{}); // expected-error{{no matching function for call to 'add2'}} \ No newline at end of file Index: clang/test/CXX/expr/expr.prim/expr.prim.req/requires-expr.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/requires-expr.cpp @@ -0,0 +1,68 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +using A = int; + +template +constexpr bool is_same_v = false; + +template +constexpr bool is_same_v = true; + +template +concept same_as = is_same_v; + +static_assert(requires { requires true; 0; typename A; + { 0 } -> same_as; }); +static_assert(is_same_v); + +// Check that requires expr is an unevaluated context. +struct Y { + int i; + static constexpr bool r = requires { i; }; +}; + +template requires requires (T t) { + requires false; // expected-note{{because 'false' evaluated to false}} + requires false; + requires requires { + requires false; + }; +} +struct r1 { }; + +using r1i = r1; +// expected-error@-1 {{constraints not satisfied for class template 'r1' [with T = int]}} + +template requires requires (T t) { + requires requires { + requires false; // expected-note{{because 'false' evaluated to false}} + }; +} +struct r2 { }; + +using r2i = r2; +// expected-error@-1 {{constraints not satisfied for class template 'r2' [with T = int]}} + +template requires requires (T t) { + requires requires { + requires true; + }; + requires true; + requires requires { + requires false; // expected-note{{because 'false' evaluated to false}} + }; +} +struct r3 { }; + +using r3i = r3; +// expected-error@-1 {{constraints not satisfied for class template 'r3' [with T = int]}} + +template +struct S { static const int s = T::value; }; + +template requires requires { T::value; S::s; } +// expected-note@-1 {{because 'T::value' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} +struct r4 { }; + +using r4i = r4; +// expected-error@-1 {{constraints not satisfied for class template 'r4' [with T = int]}} \ No newline at end of file Index: clang/test/CXX/expr/expr.prim/expr.prim.req/simple-requirement.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/simple-requirement.cpp @@ -0,0 +1,97 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +static_assert(requires { 0; }); +static_assert(requires { "aaaa"; }); +static_assert(requires { (0).da; }); // expected-error{{member reference base type 'int' is not a structure or union}} + +struct A {}; +struct B { + B operator+(const B &other) const { return other; } +}; +struct C { + C operator+(C &other) const { return other; } +}; + +template requires requires (T a, const T& b) { a + b; } +// expected-note@-1{{because 'a + b' would be invalid: invalid operands to binary expression ('A' and 'const A')}} +// expected-note@-2{{because 'a + b' would be invalid: invalid operands to binary expression ('C' and 'const C')}} +struct r1 {}; + +using r1i1 = r1; +using r1i2 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = A]}} +using r1i3 = r1; +using r1i4 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}} + +struct D { void foo() {} }; + +template requires requires (T a) { a.foo(); } +// expected-note@-1{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}} +// expected-note@-2{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}} +// expected-note@-3{{because 'a.foo()' would be invalid: 'this' argument to member function 'foo' has type 'const D', but function is not marked const}} +struct r2 {}; + +using r2i1 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}} +using r2i2 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}} +using r2i3 = r2; +using r2i4 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}} + +template requires requires { sizeof(T); } +// expected-note@-1{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} +// expected-note@-2{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}} +struct r3 {}; + +using r3i1 = r3; +using r3i2 = r3; +using r3i3 = r3; +using r3i4 = r3; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}} +using r3i4 = r3; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}} + +template requires requires (T t) { 0; "a"; (void)'a'; } +struct r4 {}; + +using r4i1 = r4; +using r4i2 = r4; +using r4i3 = r4; + +template void f(T) = delete; +template requires (sizeof(T) == 1) void f(T) { } + +template requires requires(T t) { f(t); } +// expected-note@-1{{because 'f(t)' would be invalid: call to deleted function 'f'}} +struct r5 {}; + +using r5i1 = r5; +// expected-error@-1 {{constraints not satisfied for class template 'r5' [with T = int]}} +using r5i2 = r5; + +template +struct E { + struct non_default_constructible { non_default_constructible(T t) { } }; +}; + +template requires requires(T t) { typename E::non_default_constructible{}; } +// expected-note@-1 {{because 'typename E::non_default_constructible({})' would be invalid: no matching constructor for initialization of 'typename E::non_default_constructible'}} +struct r6 {}; + +using r6i1 = r6; +// expected-error@-1 {{constraints not satisfied for class template 'r6' [with T = int]}} + +template requires requires(T t) { typename E::non_default_constructible(); } +// expected-note@-1 {{because 'typename E::non_default_constructible()' would be invalid: no matching constructor for initialization of 'typename E::non_default_constructible'}} +struct r7 {}; + +using r7i1 = r7; +// expected-error@-1 {{constraints not satisfied for class template 'r7' [with T = int]}} + +// C++ [expr.prim.req.simple] Example +namespace std_example { + template concept C = + requires (T a, T b) { // expected-note{{because substituted constraint expression is ill-formed: argument may not have 'void' type}} + a + b; // expected-note{{because 'a + b' would be invalid: invalid operands to binary expression ('int *' and 'int *')}} + }; + + static_assert(C); + template struct C_check {}; // expected-note{{because 'void' does not satisfy 'C'}} expected-note{{because 'int *' does not satisfy 'C'}} + using c1c1 = C_check; // expected-error{{constraints not satisfied for class template 'C_check' [with T = void]}} + using c1c2 = C_check; // expected-error{{constraints not satisfied for class template 'C_check' [with T = int *]}} +} \ No newline at end of file Index: clang/test/CXX/expr/expr.prim/expr.prim.req/type-requirement.cpp =================================================================== --- /dev/null +++ clang/test/CXX/expr/expr.prim/expr.prim.req/type-requirement.cpp @@ -0,0 +1,193 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +using A = int; + +template using identity_t = T; // expected-note 4{{template is declared here}}} + +template struct identity { using type = T; }; +// expected-note@-1 2{{template is declared here}} + +struct C {}; + +struct D { static int type; }; // expected-note{{referenced member 'type' is declared here}} + +// Basic unqualified and global-qualified lookups + +static_assert(requires { typename A; typename ::A; }); +static_assert(requires { typename identity_t; typename ::identity_t; }); +static_assert(!requires { typename identity_t; }); // expected-error{{too many template arguments for alias template 'identity_t'}} +static_assert(!requires { typename ::identity_t; }); // expected-error{{too many template arguments for alias template 'identity_t'}} +static_assert(requires { typename identity; }); +static_assert(!requires { typename identity; }); +// expected-error@-1 {{use of class template 'identity' requires template arguments; argument deduction not allowed here}} +static_assert(!requires { typename ::identity; }); +// expected-error@-1 {{use of class template 'identity' requires template arguments; argument deduction not allowed here}} +static_assert(!requires { typename identity_t; }); +// expected-error@-1 {{use of alias template 'identity_t' requires template arguments; argument deduction not allowed here}} +static_assert(!requires { typename ::identity_t; }); +// expected-error@-1 {{use of alias template 'identity_t' requires template arguments; argument deduction not allowed here}} + +namespace ns { + using B = int; + int C = 0; + // expected-note@-1 {{struct 'C' is hidden by a non-type declaration of 'C' here}} + static_assert(requires { typename A; typename B; typename ::A; }); + static_assert(!requires { typename ns::A; }); // expected-error{{no type named 'A' in namespace 'ns'}} + static_assert(!requires { typename ::B; }); // expected-error{{no type named 'B' in the global namespace}} + static_assert(requires { typename C; }); + // expected-error@-1 {{must use 'struct' tag to refer to type 'C' in this scope}} +} + +// member type lookups + +static_assert(requires { typename identity::type; typename ::identity::type; }); +static_assert(!requires { typename identity::typr; }); // expected-error{{no type named 'typr' in 'identity'}} +static_assert(!requires { typename ::identity::typr; }); // expected-error{{no type named 'typr' in 'identity'}} + +template requires requires { typename T::type; } +// expected-note@-1 {{because 'typename T::type' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} +// expected-note@-2 {{because 'typename T::type' would be invalid: no type named 'type' in 'C'}} +// expected-note@-3 {{because 'typename T::type' would be invalid: typename specifier refers to non-type member 'type' in 'D'}} +// expected-note@-4 {{in instantiation of template class 'invalid' requested here}} +// expected-note@-5 {{in instantiation of requirement here}} +// expected-note@-6 {{while substituting template arguments into constraint expression here}} +// expected-note@-7 {{because 'typename T::type' would be invalid}} +struct r1 {}; + +using r1i1 = r1>; +using r1i2 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}} +using r1i3 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = C]}} +using r1i4 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = D]}} + +template struct invalid { typename T::type x; }; +// expected-error@-1 {{typename specifier refers to non-type member 'type' in 'D'}} +using r1i5 = r1>; +// expected-error@-1 {{constraints not satisfied for class template 'r1' [with T = invalid]}} +// expected-note@-2 {{while checking constraint satisfaction for template 'r1 >' required here}} + +// mismatching template arguments + +template requires requires { typename identity; } // expected-note{{because 'identity' would be invalid: too many template arguments for class template 'identity'}} +struct r2 {}; + +using r2i1 = r2; +using r2i2 = r2; +using r2i3 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with Ts = ]}} + +namespace ns2 { + template struct identity {}; + + template requires requires { typename identity; } // expected-note 2{{because 'identity' would be invalid: too few template arguments for class template 'identity'}} + struct r4 {}; + + using r4i1 = r4; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = ]}} +} + +using r4i2 = ns2::r4; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = ]}} + +using E = int; +template requires requires { typename E; } // expected-error{{expected ';' at end of requirement}} +struct r5v1 {}; +template requires requires { typename ::E; } // expected-error{{expected ';' at end of requirement}} +struct r5v2 {}; + +template requires (sizeof(T) == 1) +struct chars_only {}; + +template requires requires { typename chars_only; } // expected-note{{because 'chars_only' would be invalid: constraints not satisfied for class template 'chars_only' [with T = int]}} +struct r6 {}; + +using r6i = r6; // expected-error{{constraints not satisfied for class template 'r6' [with T = int]}} + +template int F = 0; + +static_assert(!requires { typename F; }); // expected-error{{expected a type}} +static_assert(!requires { typename ::F; }); // expected-error{{typename specifier refers to a non-type template}} + +struct G { template static T temp; }; + +template requires requires { typename T::template temp; } +// expected-note@-1{{because 'typename T::temp' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} +// expected-note@-2{{because 'typename T::temp' would be invalid: no member named 'temp' in 'D'}} +// expected-note@-3{{because 'typename T::temp' would be invalid: template name refers to non-type template 'G::template temp'}} +struct r7 {}; + +using r7i1 = r7; // expected-error{{constraints not satisfied for class template 'r7' [with T = int]}} +using r7i2 = r7; // expected-error{{constraints not satisfied for class template 'r7' [with T = D]}} +using r7i3 = r7; // expected-error{{constraints not satisfied for class template 'r7' [with T = G]}} + +template struct H; + +template requires requires { typename H; } +struct r8 {}; + +using r8i = r8; + +template struct I { struct incomplete; }; // expected-note{{member is declared here}} + +static_assert(!requires { I::incomplete::inner; }); // expected-error{{implicit instantiation of undefined member 'I::incomplete'}} + +template requires requires { typename I::incomplete::inner; } // expected-note{{because 'typename I::incomplete::inner' would be invalid: implicit instantiation of undefined member 'I::incomplete'}} +struct r9 {}; + +using r9i = r9; // expected-error{{constraints not satisfied for class template 'r9' [with T = int]}} + +namespace ns3 { + struct X { }; // expected-note 2{{candidate found by name lookup is 'ns3::X'}} +} + +struct X { using inner = int; }; // expected-note 2{{candidate found by name lookup is 'X'}} + +using namespace ns3; +static_assert(requires { typename X; }); // expected-error{{reference to 'X' is ambiguous}} +static_assert(requires { typename X::inner; }); +// expected-error@-1{{reference to 'X' is ambiguous}} +// expected-error@-2{{expected a qualified name after 'typename'}} + +// naming a type template specialization in a type requirement does not require +// it to be complete and should not care about partial specializations. + +template +struct Z; + +template requires (sizeof(T) >= 1) +struct Z {}; // expected-note{{partial specialization matches [with T = int]}} + +template requires (sizeof(T) <= 4) +struct Z {}; // expected-note{{partial specialization matches [with T = int]}} + +Z x; // expected-error{{ambiguous partial specializations of 'Z'}} + +static_assert(requires { typename Z; }); + +// C++ [expr.prim.req.type] Example +namespace std_example { + template struct S; + // expected-note@-1 {{because 'S' would be invalid: no type named 'type' in 'std_example::has_inner}} + template using Ref = T&; // expected-note{{because 'Ref' would be invalid: cannot form a reference to 'void'}} + template concept C1 = + requires { + typename T::inner; + // expected-note@-1 {{because 'typename T::inner' would be invalid: type 'int' cannot be used prior to '::' because it has no members}} + // expected-note@-2 {{because 'typename T::inner' would be invalid: no type named 'inner' in 'std_example::has_type'}} + }; + template concept C2 = requires { typename S; }; + template concept C3 = requires { typename Ref; }; + + struct has_inner { using inner = int;}; + struct has_type { using type = int; }; + struct has_inner_and_type { using inner = int; using type = int; }; + + static_assert(C1 && C2 && C3); + template struct C1_check {}; + // expected-note@-1 {{because 'int' does not satisfy 'C1'}} + // expected-note@-2 {{because 'std_example::has_type' does not satisfy 'C1'}} + template struct C2_check {}; + // expected-note@-1 {{because 'std_example::has_inner' does not satisfy 'C2'}} + template struct C3_check {}; + // expected-note@-1 {{because 'void' does not satisfy 'C3'}} + using c1 = C1_check; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = int]}} + using c2 = C1_check; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = std_example::has_type]}} + using c3 = C2_check; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::has_inner]}} + using c4 = C3_check; // expected-error{{constraints not satisfied for class template 'C3_check' [with T = void]}} +} \ No newline at end of file Index: clang/test/PCH/cxx2a-requires-expr.cpp =================================================================== --- /dev/null +++ clang/test/PCH/cxx2a-requires-expr.cpp @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -emit-pch -std=c++2a -fconcepts-ts -o %t %s +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x ast -ast-print %t | FileCheck %s + +template +concept C = true; + +template +concept C2 = true; + +template +bool f() { + // CHECK: requires (T t) { t++; { t++ } noexcept -> C; { t++ } -> C2; typename T::a; requires T::val; }; + return requires (T t) { + t++; + { t++ } noexcept -> C; + { t++ } -> C2; + typename T::a; + requires T::val; + }; +} Index: clang/test/Parser/cxx2a-concepts-requires-expr.cpp =================================================================== --- /dev/null +++ clang/test/Parser/cxx2a-concepts-requires-expr.cpp @@ -0,0 +1,141 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify + +bool r1 = requires () {}; +// expected-error@-1 {{a requires expression must contain at least one requirement}} + +bool r2 = requires { requires true; }; + +bool r3 = requires (int a, ...) { requires true; }; +// expected-error@-1 {{varargs not allowed in requires expression}} + +template +bool r4 = requires (T... ts) { requires true; }; + +bool r5 = requires (bool c, int d) { c; d; }; + +bool r6 = requires (bool c, int d) { c; d; } && decltype(d){}; +// expected-error@-1 {{use of undeclared identifier 'd'}} + +bool r7 = requires (bool c) { c; (requires (int d) { c; d; }); d; } && decltype(c){} && decltype(d){}; +// expected-error@-1 2{{use of undeclared identifier 'd'}} +// expected-error@-2 {{use of undeclared identifier 'c'}} + +bool r8 = requires (bool, int) { requires true; }; + +bool r9 = requires (bool a, int a) { requires true; }; +// expected-error@-1 {{redefinition of parameter 'a'}} +// expected-note@-2 {{previous declaration is here}} + +bool r10 = requires (struct new_struct { int x; } s) { requires true; }; +// expected-error@-1 {{'new_struct' cannot be defined in a parameter type}} + +bool r11 = requires (int x(1)) { requires true; }; +// expected-error@-1 {{expected parameter declarator}} +// expected-error@-2 {{expected ')'}} +// expected-note@-3 {{to match this '('}} + +bool r12 = requires (int x = 10) { requires true; }; +// expected-error@-1 {{default arguments not allowed for parameters of a requires expression}} + +bool r13 = requires (int f(int)) { requires true; }; + +bool r14 = requires (int (*f)(int)) { requires true; }; + +bool r15 = requires (10) { requires true; }; +// expected-error@-1 {{expected parameter declarator}} + +bool r16 = requires (auto x) { requires true; }; +// expected-error@-1 {{'auto' not allowed in requires expression parameter}} + +bool r17 = requires (auto [x, y]) { requires true; }; +// expected-error@-1 {{'auto' not allowed in requires expression parameter}} +// expected-error@-2 {{use of undeclared identifier 'x'}} + +using a = int; + +bool r18 = requires { typename a; }; + +bool r19 = requires { typename ::a; }; + +template struct identity { using type = T; }; + +template using identity_t = T; + +bool r20 = requires { + typename identity::type; + typename identity; + typename ::identity_t; +}; + +struct s { bool operator==(const s&); ~s(); }; + +bool r21 = requires { typename s::operator==; }; +// expected-error@-1 {{expected an identifier or template-id after '::'}} + +bool r22 = requires { typename s::~s; }; +// expected-error@-1 {{expected an identifier or template-id after '::'}} + +template +bool r23 = requires { typename identity::temp; }; +// expected-error@-1 {{use 'template' keyword to treat 'temp' as a dependent template name}} + +template +bool r24 = requires { + typename identity::template temp; + typename identity::template temp; // expected-error{{expected an identifier or template-id after '::'}} +}; + +bool r25 = requires { ; }; +// expected-error@-1 {{expected expression}} + +bool r26 = requires { {}; }; +// expected-error@-1 {{expected expression}} + +bool r27 = requires { { 0 } noexcept; }; + +bool r28 = requires { { 0 } noexcept noexcept; }; +// expected-error@-1 {{expected '->' before expression type requirement}} +// expected-error@-2 {{expected concept name with optional arguments}} + +template +concept C1 = true; + +template +concept C2 = true; + +bool r29 = requires { { 0 } noexcept C1; }; +// expected-error@-1 {{expected '->' before expression type requirement}} + +bool r30 = requires { { 0 } noexcept -> C2; }; + +template +T i1 = 0; + +bool r31 = requires { requires false, 1; }; +// expected-error@-1 {{expected ';' at end of requirement}} + +bool r32 = requires { 0 noexcept; }; +// expected-error@-1 {{'noexcept' can only be used in a compound requirements (with '{' '}' around the expression)}} + +bool r33 = requires { 0 int; }; +// expected-error@-1 {{unexpected int after expression; did you intend to use a compound requirement (with '{' '}' around the expression)?}} + +bool r34 = requires { requires true }; +// expected-error@-1 {{expected ';' at end of requirement}} + +bool r35 = requires (bool b) { requires sizeof(b) == 1; }; + +void r36(bool b) requires requires { 1 } {} +// expected-error@-1 {{expected ';' at end of requirement}} + +bool r37 = requires { requires { 1; }; }; +// expected-warning@-1 {{this requires expression will only be checked for syntactic validity; did you intend to place it in a nested requirement (add another 'requires' before the expression)}} + +bool r38 = requires { requires () { 1; }; }; +// expected-warning@-1 {{this requires expression will only be checked for syntactic validity; did you intend to place it in a nested requirement (add another 'requires' before the expression)}} + +bool r39 = requires { requires (int i) { i; }; }; +// expected-warning@-1 {{this requires expression will only be checked for syntactic validity; did you intend to place it in a nested requirement (add another 'requires' before the expression)}} + +bool r40 = requires { requires (); }; +// expected-error@-1 {{expected expression}} Index: clang/test/SemaTemplate/instantiate-requires-expr.cpp =================================================================== --- /dev/null +++ clang/test/SemaTemplate/instantiate-requires-expr.cpp @@ -0,0 +1,216 @@ +// RUN: %clang_cc1 -std=c++2a -fconcepts-ts -x c++ %s -verify -Wno-unused-value + +template +constexpr bool is_same_v = false; + +template +constexpr bool is_same_v = true; + +// We use a hack in this file to make the compiler print out the requires +// expression after it has been instantiated - we put false_v as +// the requires clause of a class template, then instantiate the template. +// The requirement will not be satisfied, and the explaining diagnostic will +// print out false_v in its raw form (the false_v serves to +// prevent the diagnostic from elaborating on why the requires expr wasn't +// satisfied). + +template +constexpr bool false_v = false; + +template +using void_t = void; + +// Check that requires parameters are instantiated correctly. + +template requires +false_v; }> +// expected-note@-1 {{because 'false_v; }>' evaluated to false}} +// expected-note@-2 {{because 'false_v; }>' evaluated to false}} +struct r1 {}; + +using r1i1 = r1; // expected-error {{constraints not satisfied for class template 'r1' [with T = int]}} +using r1i2 = r1; // expected-error {{constraints not satisfied for class template 'r1' [with T = char]}} + +// Check that parameter packs work. + +template requires +false_v +// expected-note@-1 {{because 'false_v'}} +// expected-note@-2 {{because 'false_v' evaluated to false}} +struct r2 {}; + +using r2i1 = r2; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = ]}} +using r2i2 = r2; // expected-error {{constraints not satisfied for class template 'r2' [with Ts = ]}} + +template requires +false_v<(requires (Ts ts) {requires sizeof(ts) != 0;} && ...)> +// expected-note@-1 {{because 'false_v' evaluated to false}} +// expected-note@-2 {{because 'false_v' evaluated to false}} +struct r3 {}; + +using r3i1 = r3; // expected-error {{constraints not satisfied for class template 'r3' [with Ts = ]}} +using r3i2 = r3; // expected-error {{constraints not satisfied for class template 'r3' [with Ts = ]}} + +template +struct identity { using type = T; }; + +namespace type_requirement { + struct A {}; + + // check that nested name specifier is instantiated correctly. + template requires false_v // expected-note{{because 'false_v::type; }>' evaluated to false}} + struct r1 {}; + + using r1i = r1>; // expected-error{{constraints not satisfied for class template 'r1' [with T = identity]}} + + // check that template argument list is instantiated correctly. + template + struct contains_template { + template requires is_same_v, U> + using temp = int; + }; + + template requires + false_v; }> + // expected-note@-1 {{because 'false_v::temp >; }>' evaluated to false}} + // expected-note@-2 {{because 'false_v::temp >; }>' evaluated to false}} + struct r2 {}; + + using r2i1 = r2>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template]}} + using r2i2 = r2>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template]}} + + // substitution error occurs, then requires expr is instantiated again + + template + struct a { + template requires (requires { typename T::a::a; }, false) + // expected-note@-1{{because 'requires { typename <>; } , false' evaluated to false}} + struct r {}; + }; + + using ari = a::r; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}} + + // Parameter pack inside expr + template requires + false_v<(requires { typename Ts::type; } && ...)> + // expected-note@-1 {{because 'false_v::type; } && requires { typename identity::type; } && requires { typename <>; }>' evaluated to false}} + struct r5 {}; + + using r5i = r5, identity, short>; // expected-error{{constraints not satisfied for class template 'r5' [with Ts = , identity, short>]}} + template requires + false_v<(requires { typename void_t; } && ...)> // expected-note{{because 'false_v; } && requires { typename void_t; }>' evaluated to false}} + struct r6 {}; + + using r6i = r6; // expected-error{{constraints not satisfied for class template 'r6' [with Ts = ]}} + + template requires + false_v<(requires { typename Ts::template aaa; } && ...)> + // expected-note@-1 {{because 'false_v>; } && requires { typename <>; }>' evaluated to false}} + struct r7 {}; + + using r7i = r7; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = ]}} +} + +namespace expr_requirement { + // check that compound/simple requirements are instantiated correctly. + + template requires false_v + // expected-note@-1 {{because 'false_v' evaluated to false}} + // expected-note@-2 {{because 'false_v>; { sizeof(T) }; }>' evaluated to false}} + struct r1 {}; + + using r1i1 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}} + using r1i2 = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = void]}} + + // substitution error occurs in expr, then expr is instantiated again. + + template + struct a { + template requires (requires { sizeof(T::a); }, false) // expected-note{{because 'requires { <>; } , false' evaluated to false}} + struct r {}; + }; + + using ari = a::r; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}} + + // check that the return-type-requirement is instantiated correctly. + + template + concept C1 = is_same_v; + + template requires false_v C1; }> + // expected-note@-1 {{because 'false_v C1; }>' evaluated to false}} + // expected-note@-2 {{because 'false_v C1; }>' evaluated to false}} + struct r2 {}; + + using r2i1 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}} + using r2i2 = r2; // expected-error{{constraints not satisfied for class template 'r2' [with T = double]}} + + + // substitution error occurs in return type requirement, then requires expr is + // instantiated again. + + template + struct b { + template requires (requires { { 0 } -> C1; }, false) // expected-note{{because 'requires { { 0 } -> <>; } , false' evaluated to false}} + struct r {}; + }; + + using bri = b::r; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}} + + + template requires + false_v<(requires { { 0 } noexcept -> C1; } && ...)> + // expected-note@-1 {{because 'false_v C1; } && requires { { 0 } noexcept -> C1; }>' evaluated to false}} + struct r3 {}; + + using r3i = r3; // expected-error{{constraints not satisfied for class template 'r3' [with Ts = ]}} +} + +namespace nested_requirement { + // check that constraint expression is instantiated correctly + template requires false_v // expected-note{{because 'false_v' evaluated to false}} + struct r1 {}; + + using r1i = r1; // expected-error{{constraints not satisfied for class template 'r1' [with T = int]}} + + // substitution error occurs in expr, then expr is instantiated again. + template + struct a { + template requires + (requires { requires sizeof(T::a) == 0; }, false) // expected-note{{because 'requires { requires <>; } , false' evaluated to false}} + struct r {}; + }; + + using ari = a::r; // expected-error{{constraints not satisfied for class template 'r' [with U = short]}} + + // Parameter pack inside expr + template requires + false_v<(requires { requires sizeof(Ts) == 0; } && ...)> + // expected-note@-1 {{because 'false_v' evaluated to false}} + struct r2 {}; + + using r2i = r2; // expected-error{{constraints not satisfied for class template 'r2' [with Ts = ]}} +} + +// Parameter pack inside multiple requirements +template requires +false_v<(requires { requires sizeof(Ts) == 0; sizeof(Ts); } && ...)> +// expected-note@-1 {{because 'false_v' evaluated to false}} +struct r4 {}; + +using r4i = r4; // expected-error{{constraints not satisfied for class template 'r4' [with Ts = ]}} + +template requires +false_v<(requires(Ts t) { requires sizeof(t) == 0; t++; } && ...)> +// expected-note@-1 {{because 'false_v' evaluated to false}} +struct r5 {}; + +using r5i = r5; // expected-error{{constraints not satisfied for class template 'r5' [with Ts = ]}} + +template requires +false_v<(requires(T t) { T{t}; })> // T{t} creates an "UnevaluatedList" context. +// expected-note@-1 {{because 'false_v<(requires (int t) { int{t}; })>' evaluated to false}} +struct r6 {}; + +using r6i = r6; +// expected-error@-1 {{constraints not satisfied for class template 'r6' [with T = int]}} Index: clang/tools/libclang/CIndex.cpp =================================================================== --- clang/tools/libclang/CIndex.cpp +++ clang/tools/libclang/CIndex.cpp @@ -6340,6 +6340,7 @@ case Decl::UsingPack: case Decl::Concept: case Decl::LifetimeExtendedTemporary: + case Decl::RequiresExprBody: return C; // Declaration kinds that don't make any sense here, but are Index: clang/tools/libclang/CXCursor.cpp =================================================================== --- clang/tools/libclang/CXCursor.cpp +++ clang/tools/libclang/CXCursor.cpp @@ -257,6 +257,7 @@ case Stmt::TypeTraitExprClass: case Stmt::CoawaitExprClass: case Stmt::ConceptSpecializationExprClass: + case Stmt::RequiresExprClass: case Stmt::DependentCoawaitExprClass: case Stmt::CoyieldExprClass: case Stmt::CXXBindTemporaryExprClass: