[Concepts] Requires Expressions (a0f50d73) · Commits · llvm-doe / llvm-project

clang/include/clang/AST/ASTConcept.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <utility>
		namespace clang {
		class ConceptDecl;
		class ConceptSpecializationExpr;

		/// \brief The result of a constraint satisfaction check, containing the
		/// necessary information to diagnose an unsatisfied constraint.

clang/include/clang/AST/DeclCXX.h

+31 −0

Original line number	Diff line number	Diff line
		@@ -1893,6 +1893,37 @@ public:
		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<typename T> 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

clang/include/clang/AST/ExprCXX.h

+0 −94

Original line number	Diff line number	Diff line
		@@ -14,7 +14,6 @@
		#ifndef LLVM_CLANG_AST_EXPRCXX_H
		#define LLVM_CLANG_AST_EXPRCXX_H

		#include "clang/AST/ASTConcept.h"
		#include "clang/AST/Decl.h"
		#include "clang/AST/DeclBase.h"
		#include "clang/AST/DeclCXX.h"
		@@ -4836,99 +4835,6 @@ public:
		}
		};

		/// \brief Represents the specialization of a concept - evaluates to a prvalue
		/// of type bool.
		///
		/// According to C++2a [expr.prim.id]p3 an id-expression that denotes the
		/// specialization of a concept results in a prvalue of type bool.
		class ConceptSpecializationExpr final : public Expr, public ConceptReference,
		private llvm::TrailingObjects<ConceptSpecializationExpr,
		TemplateArgument> {
		friend class ASTStmtReader;
		friend TrailingObjects;
		public:
		using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>;

		protected:
		/// \brief The number of template arguments in the tail-allocated list of
		/// converted template arguments.
		unsigned NumTemplateArgs;

		/// \brief Information about the satisfaction of the named concept with the
		/// given arguments. If this expression is value dependent, this is to be
		/// ignored.
		ASTConstraintSatisfaction *Satisfaction;

		ConceptSpecializationExpr(const ASTContext &C, NestedNameSpecifierLoc NNS,
		SourceLocation TemplateKWLoc,
		DeclarationNameInfo ConceptNameInfo,
		NamedDecl FoundDecl, ConceptDecl NamedConcept,
		const ASTTemplateArgumentListInfo *ArgsAsWritten,
		ArrayRef<TemplateArgument> ConvertedArgs,
		const ConstraintSatisfaction *Satisfaction);

		ConceptSpecializationExpr(EmptyShell Empty, unsigned NumTemplateArgs);

		public:

		static ConceptSpecializationExpr *
		Create(const ASTContext &C, NestedNameSpecifierLoc NNS,
		SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
		NamedDecl FoundDecl, ConceptDecl NamedConcept,
		const ASTTemplateArgumentListInfo *ArgsAsWritten,
		ArrayRef<TemplateArgument> ConvertedArgs,
		const ConstraintSatisfaction *Satisfaction);

		static ConceptSpecializationExpr *
		Create(ASTContext &C, EmptyShell Empty, unsigned NumTemplateArgs);

		ArrayRef<TemplateArgument> getTemplateArguments() const {
		return ArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(),
		NumTemplateArgs);
		}

		/// \brief Set new template arguments for this concept specialization.
		void setTemplateArguments(ArrayRef<TemplateArgument> Converted);

		/// \brief Whether or not the concept with the given arguments was satisfied
		/// when the expression was created.
		/// The expression must not be dependent.
		bool isSatisfied() const {
		assert(!isValueDependent()
		&& "isSatisfied called on a dependent ConceptSpecializationExpr");
		return Satisfaction->IsSatisfied;
		}

		/// \brief Get elaborated satisfaction info about the template arguments'
		/// satisfaction of the named concept.
		/// The expression must not be dependent.
		const ASTConstraintSatisfaction &getSatisfaction() const {
		assert(!isValueDependent()
		&& "getSatisfaction called on dependent ConceptSpecializationExpr");
		return *Satisfaction;
		}

		static bool classof(const Stmt *T) {
		return T->getStmtClass() == ConceptSpecializationExprClass;
		}

		SourceLocation getBeginLoc() const LLVM_READONLY {
		return ConceptName.getBeginLoc();
		}

		SourceLocation getEndLoc() const LLVM_READONLY {
		return ArgsAsWritten->RAngleLoc;
		}

		// 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

clang/include/clang/AST/ExprConcepts.h

0 → 100644

+540 −0

File added.

Preview size limit exceeded, changes collapsed.

clang/include/clang/AST/RecursiveASTVisitor.h

+25 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include "clang/AST/DeclOpenMP.h"
		#include "clang/AST/DeclTemplate.h"
		#include "clang/AST/Expr.h"
		#include "clang/AST/ExprConcepts.h"
		#include "clang/AST/ExprCXX.h"
		#include "clang/AST/ExprObjC.h"
		#include "clang/AST/ExprOpenMP.h"
		@@ -2138,6 +2139,8 @@ DEF_TRAVERSE_DECL(ParmVarDecl, {
		TRY_TO(TraverseStmt(D->getDefaultArg()));
		})

		DEF_TRAVERSE_DECL(RequiresExprBodyDecl, {})

		#undef DEF_TRAVERSE_DECL

		// ----------------- Stmt traversal -----------------
		@@ -2709,6 +2712,28 @@ DEF_TRAVERSE_STMT(ConceptSpecializationExpr, {
		TRY_TO(TraverseConceptReference(*S));
		})

		DEF_TRAVERSE_STMT(RequiresExpr, {
		TRY_TO(TraverseDecl(S->getBody()));
		for (ParmVarDecl *Parm : S->getLocalParameters())
		TRY_TO(TraverseDecl(Parm));
		for (concepts::Requirement *Req : S->getRequirements())
		if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
		if (!TypeReq->isSubstitutionFailure())
		TRY_TO(TraverseTypeLoc(TypeReq->getType()->getTypeLoc()));
		} else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(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<concepts::NestedRequirement>(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, {})